rpg-engine 0.0.0-stage → 0.1.0

package/dist/rules/search.js

@@ -0,0 +1,101 @@
+import { comparableText } from "../core/text.js";
+/**
+ * The sections that a text finds, best first (RUL-3, RUL-5): those it names, then those with its words, the rarest words weighing most, in the title most of all.
+ * After sections it names, the others are found by the words of its last title alone: "Combat › Grappling" looks for grappling.
+ */
+export function findRules(sections, text) {
+    const titled = sections.filter((section) => isTitled(section, text));
+    const searched = [...new Set(searchWords(titled.length > 0 ? (titlesIn(text).at(-1) ?? "") : text))];
+    const named = titled.map((section) => ({ section, titled: true, score: Infinity }));
+    if (searched.length === 0) {
+        return named;
+    }
+    const indexed = sections.map((section, index) => ({ section, index, ...wordsOf(section) }));
+    const having = searched.map((word) => indexed.filter((entry) => [entry.title, entry.above, entry.text].some((words) => hasForm(words, word))).length);
+    // A word weighs more the fewer sections have it, and never nothing, so that a book of one section is found too.
+    const weights = having.map((count) => 1 + Math.log((sections.length + 1) / (count + 1)));
+    // A word that more than half of the sections have, such as "in" or "a", finds nothing by itself.
+    const telling = searched.filter((_, index) => sections.length < 2 || having[index] <= sections.length / 2);
+    const scored = indexed
+        .filter((entry) => !titled.includes(entry.section) && telling.some((word) => [entry.title, entry.above, entry.text].some((words) => hasForm(words, word))))
+        .map((entry) => ({ entry, score: scoreOf(entry, searched, weights) }));
+    scored.sort((first, second) => second.score - first.score || titleLength(first.entry.section) - titleLength(second.entry.section) || first.entry.index - second.entry.index);
+    return [...named, ...scored.map(({ entry, score }) => ({ section: entry.section, titled: false, score }))];
+}
+/** Whether a section is the one a text names: its title, or titles of its path ending with its own, as in "Combat › Grappling". */
+export function isTitled(section, text) {
+    const titles = titlesIn(text).map(comparableText);
+    const path = section.path.map(comparableText);
+    if (titles.length === 0 || titles.at(-1) !== path.at(-1)) {
+        return false;
+    }
+    let position = 0;
+    for (const title of titles.slice(0, -1)) {
+        position = path.indexOf(title, position);
+        if (position < 0 || position >= path.length - 1) {
+            return false;
+        }
+        position++;
+    }
+    return true;
+}
+/** The titles a text gives, as in "Combat › Grappling" (› > or / between them), without the stop that may end one. */
+function titlesIn(text) {
+    return text.split(/\s*[›>/]\s*/).map((title) => title.trim().replace(/[.:]$/, "")).filter((title) => title !== "");
+}
+/** Whether a text holds every word of a search, as search compares words: what finds a precedent. */
+export function hasAllWords(text, search) {
+    const words = searchWords(text);
+    return searchWords(search).every((searched) => hasForm(words, searched));
+}
+/** The words of a text as a search compares them: letters and digits, in any case and however accents are written. */
+function searchWords(text) {
+    return comparableText(text).match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+/** The words of a section's title, of the titles above it and of its own text, each once: cut once for each section, which never changes (D-194). */
+function wordsOf(section) {
+    let words = wordsBySection.get(section);
+    if (words === undefined) {
+        const distinct = (text) => [...new Set(searchWords(text))];
+        words = { title: distinct(section.path.at(-1) ?? ""), above: distinct(section.path.slice(0, -1).join(" ")), text: distinct(section.ownText) };
+        wordsBySection.set(section, words);
+    }
+    return words;
+}
+const wordsBySection = new WeakMap();
+// A form of a word may change this many of its last letters, and must keep at least the first four (all of a shorter word).
+const formLetters = 3;
+const stemLetters = 4;
+function hasForm(words, searched) {
+    return words.some((word) => sameWord(searched, word));
+}
+/**
+ * Whether a word of a text is a form of a word searched (RUL-4): the two differ at most in their last three letters, and share at least the first four, or all of a shorter word.
+ * Grapple finds grappled and grappling, rest finds resting but not restrained, concentration not conceal; two letters find only themselves.
+ */
+function sameWord(searched, word) {
+    if (searched.length <= 2) {
+        return word === searched;
+    }
+    let common = 0;
+    while (common < searched.length && common < word.length && searched[common] === word[common]) {
+        common++;
+    }
+    // A form may double the last letter the two share, as swim and swimming do.
+    const doubledInWord = common > 0 && word[common] === word[common - 1] ? 1 : 0;
+    const doubledInSearched = common > 0 && searched[common] === searched[common - 1] ? 1 : 0;
+    return word.length - common <= formLetters + doubledInWord && common >= Math.max(Math.min(searched.length, stemLetters), searched.length - formLetters - doubledInSearched);
+}
+/** How much of a search a section holds: the weight of each word it has, and again for each word in its title (half for the titles above it). */
+function scoreOf(entry, searched, weights) {
+    let score = 0;
+    for (const [index, word] of searched.entries()) {
+        const title = hasForm(entry.title, word), above = hasForm(entry.above, word);
+        const found = title || above || hasForm(entry.text, word);
+        score += (found ? weights[index] : 0) + (title ? weights[index] : above ? weights[index] / 2 : 0);
+    }
+    return score;
+}
+function titleLength(section) {
+    return (section.path.at(-1) ?? "").length;
+}

package/dist/rules/shown.d.ts

@@ -0,0 +1,19 @@
+import type { RuleSection } from "./rule-book.ts";
+import type { RuleFinding } from "./search.ts";
+/** A section as an answer shows it: whole, or, when it is too long, its own text with the titles of its parts. */
+export interface ShownRule {
+    section: RuleSection;
+    text: string;
+    /** The titles of its parts when only its own text is shown, so that they can be asked for; none when it is whole. */
+    parts: string[];
+}
+/**
+ * What an answer shows of what a search found (RUL-6), within about `words` words: the sections the text names, or else the best ones, up to three
+ * and at least half as good as the first; each whole while it fits, never twice the same text, the first always, cut to its own text when it is too long alone.
+ * The others are only named, best first; `used` is how many words the shown ones take.
+ */
+export declare function shownRules(found: RuleFinding[], words: number): {
+    shown: ShownRule[];
+    others: RuleSection[];
+    used: number;
+};

package/dist/rules/shown.js

@@ -0,0 +1,44 @@
+// Sections shown whole when the text names none of them; the others are only named.
+const wholeFound = 3;
+/**
+ * What an answer shows of what a search found (RUL-6), within about `words` words: the sections the text names, or else the best ones, up to three
+ * and at least half as good as the first; each whole while it fits, never twice the same text, the first always, cut to its own text when it is too long alone.
+ * The others are only named, best first; `used` is how many words the shown ones take.
+ */
+export function shownRules(found, words) {
+    const anyNamed = found.some((finding) => finding.titled);
+    const best = found.find((finding) => !finding.titled)?.score ?? 0;
+    const shown = [];
+    const others = [];
+    let used = 0;
+    for (const { section, titled, score } of found) {
+        if (shown.some((entry) => entry.parts.length === 0 && holds(entry.section, section))) {
+            continue;
+        }
+        const size = wordCount(section.text);
+        const candidate = anyNamed ? titled : shown.length < wholeFound && score >= best / 2;
+        if (!candidate || shown.some((entry) => holds(section, entry.section))) {
+            others.push(section);
+        }
+        else if (used + size <= words) {
+            shown.push({ section, text: section.text, parts: [] });
+            used += size;
+        }
+        else if (shown.length === 0) {
+            shown.push({ section, text: section.ownText, parts: section.parts });
+            used += wordCount(section.ownText);
+        }
+        else {
+            others.push(section);
+        }
+    }
+    return { shown, others, used };
+}
+/** Whether a section holds another one among its parts, or is it. */
+function holds(outer, inner) {
+    return outer.source === inner.source && outer.file === inner.file && outer.path.length <= inner.path.length && outer.path.every((title, index) => inner.path[index] === title)
+        && outer.text.includes(inner.text);
+}
+function wordCount(text) {
+    return text.split(/\s+/).filter((word) => word !== "").length;
+}

package/dist/saves/index.d.ts

@@ -0,0 +1 @@
+export { packFiles, readSaves, type Save, saveFileName, unpackFiles } from "./saves.ts";

package/dist/saves/index.js

@@ -0,0 +1,2 @@
+// Saves of a campaign for any game: zips of its files, numbered and named by when they were made (D-54). Depends on nothing else in rpg-engine.
+export { packFiles, readSaves, saveFileName, unpackFiles } from "./saves.js";

package/dist/saves/saves.d.ts

@@ -0,0 +1,14 @@
+/** A save of the campaign: its number, from 1, and what names it, as its file says it, such as "day 2, 06.10 - Scontro all'ossario". */
+export interface Save {
+    number: number;
+    label: string;
+    file: string;
+}
+/** A zip of files, given by their paths inside it with forward slashes, such as world/characters/Kira.md. */
+export declare function packFiles(files: Record<string, Uint8Array>): Uint8Array;
+/** The files a zip holds, by their paths inside it; folders are left out. */
+export declare function unpackFiles(zip: Uint8Array): Record<string, Uint8Array>;
+/** The file name of a save: its number, then the game date and the label it has, such as "003 - day 2, 06.10 - Scontro all'ossario.zip". */
+export declare function saveFileName(number: number, parts: (string | undefined)[]): string;
+/** The saves among the names of the files of a folder, in the order of their numbers; other files are left out. */
+export declare function readSaves(names: string[]): Save[];

package/dist/saves/saves.js

@@ -0,0 +1,27 @@
+import { unzipSync, zipSync } from "fflate";
+// "003 - day 2, 06.10 - Scontro all'ossario.zip": the number, then what names it.
+const saveFilePattern = /^(\d{3,}) - (.+)\.zip$/;
+// What a file name cannot hold on any system: a dot stands for it, as for the colon of a time; white space, a tab or a line break too, is one space.
+const notInFileNames = /[\\/:*?"<>|\u0000-\u0008\u000e-\u001f]/g;
+// The longest label a file name takes, in characters, never cutting one in two.
+const longestLabel = 120;
+/** A zip of files, given by their paths inside it with forward slashes, such as world/characters/Kira.md. */
+export function packFiles(files) {
+    return zipSync(files, { level: 6 });
+}
+/** The files a zip holds, by their paths inside it; folders are left out. */
+export function unpackFiles(zip) {
+    return Object.fromEntries(Object.entries(unzipSync(zip)).filter(([path]) => !path.endsWith("/")));
+}
+/** The file name of a save: its number, then the game date and the label it has, such as "003 - day 2, 06.10 - Scontro all'ossario.zip". */
+export function saveFileName(number, parts) {
+    const label = parts.filter((part) => part !== undefined && part.trim() !== "").map((part) => part.replace(/\s+/g, " ").replace(notInFileNames, ".").trim());
+    return `${String(number).padStart(3, "0")} - ${label.length === 0 ? "save" : [...label.join(" - ")].slice(0, longestLabel).join("").trim()}.zip`;
+}
+/** The saves among the names of the files of a folder, in the order of their numbers; other files are left out. */
+export function readSaves(names) {
+    return names.flatMap((file) => {
+        const match = saveFilePattern.exec(file);
+        return match === null ? [] : [{ number: Number(match[1]), label: match[2], file }];
+    }).sort((first, second) => first.number - second.number);
+}

package/dist/scene/index.d.ts

@@ -0,0 +1 @@
+export { copyNames, nextTurn, readScene, type Scene, type SceneCopy, sceneTypes } from "./scene.ts";

package/dist/scene/index.js

@@ -0,0 +1,2 @@
+// Scenes for any game: who takes part, numbered copies of creatures, and the order of turns when the game has one. Depends on nothing else in rpg-engine.
+export { copyNames, nextTurn, readScene, sceneTypes } from "./scene.js";

package/dist/scene/scene.d.ts

@@ -0,0 +1,46 @@
+/** The kinds of scene, so that the master can see the variety of the game (D-39, D-111). */
+export declare const sceneTypes: readonly ["combat", "social", "exploration", "travel", "rest", "challenge", "other"];
+/** A numbered copy of a creature in the scene, such as Annegato 1: the creature it copies, and only what it changed (D-110, INH-14). */
+export type SceneCopy = {
+    creature: string;
+} & Record<string, unknown>;
+/** The open scene (D-113): who is in it, the copies of creatures, and the order of turns when the game has one. */
+export interface Scene {
+    title: string;
+    type: string;
+    /** A link to the place, such as [[Ossario]]. */
+    place?: string;
+    /** The game date the scene opened. */
+    opened?: string;
+    /** What is happening now, in one line as the player sees it, for their dashboard (SCN-11). */
+    now?: string;
+    /** Links to the characters in the scene. */
+    with: string[];
+    copies: Record<string, SceneCopy>;
+    order?: string[];
+    round?: number;
+    turn?: string;
+    /** Who left the scene: their names are never given again to a copy in it, and the log keeps them. */
+    left?: string[];
+    /** The copies that left, as they were when they left: what overcoming them gives counts when the scene closes (DAT-11). */
+    gone?: Record<string, SceneCopy>;
+    /** How many squares of a map the one whose turn it is has moved in it (GRD-5): it counts only for that round and turn. */
+    moved?: {
+        round: number;
+        turn: string;
+        squares: number;
+    };
+    /** Who attacks the party, as the master marks them, characters or copies by name (D-415): the player's dashboard shows it in a fight. */
+    hostile?: string[];
+    /** What the player character sees of who it does not know by name, by the character's or the creature's name, such as brigante incappucciato (D-416). */
+    seen?: Record<string, string>;
+}
+/** The open scene, checked; a scene written wrongly by hand fails with what is wrong. */
+export declare function readScene(value: unknown): Scene;
+/** Names for `count` new copies of a creature, numbered after the copies of it that `taken` already holds: Annegato 3, Annegato 4. */
+export declare function copyNames(creature: string, count: number, taken: string[]): string[];
+/** The turn after the current one, and the round: after the last in the order comes the first, in the next round. */
+export declare function nextTurn(order: string[], turn: string | undefined, round: number): {
+    turn: string;
+    round: number;
+};

package/dist/scene/scene.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { comparableText } from "../core/text.js";
+/** The kinds of scene, so that the master can see the variety of the game (D-39, D-111). */
+export const sceneTypes = ["combat", "social", "exploration", "travel", "rest", "challenge", "other"];
+// Loose: keys written by hand in the scene stay.
+const sceneSchema = z.looseObject({
+    title: z.string().min(1),
+    type: z.enum(sceneTypes),
+    place: z.string().optional(),
+    opened: z.string().optional(),
+    now: z.string().optional(),
+    with: z.array(z.string()).default([]),
+    copies: z.record(z.string(), z.looseObject({ creature: z.string() })).default({}),
+    order: z.array(z.string()).min(1).optional(),
+    round: z.number().int().positive().optional(),
+    turn: z.string().optional(),
+    left: z.array(z.string()).optional(),
+    gone: z.record(z.string(), z.looseObject({ creature: z.string() })).optional(),
+    // Written by hand, who is hostile may be one text, a list of one, and what is seen a number, as a text.
+    hostile: z.union([z.array(z.string()), z.string().transform((one) => [one])]).optional(),
+    seen: z.record(z.string(), z.union([z.string(), z.number().transform(String)])).optional(),
+    // What the engine counts, never the master: written wrongly by hand it is forgotten, never a scene that cannot be read.
+    moved: z.object({ round: z.number().int().positive(), turn: z.string(), squares: z.number().nonnegative() }).optional().catch(undefined),
+});
+/** The open scene, checked; a scene written wrongly by hand fails with what is wrong. */
+export function readScene(value) {
+    const parsed = sceneSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new Error(`${parsed.error.issues.map((issue) => `${issue.path.join(".") || "scene"}: ${issue.message}`).join("; ")}.`);
+    }
+    return parsed.data;
+}
+/** Names for `count` new copies of a creature, numbered after the copies of it that `taken` already holds: Annegato 3, Annegato 4. */
+export function copyNames(creature, count, taken) {
+    const prefix = `${comparableText(creature)} `;
+    const used = taken.map(comparableText).filter((name) => name.startsWith(prefix)).map((name) => Number(name.slice(prefix.length))).filter(Number.isSafeInteger);
+    const last = Math.max(0, ...used);
+    return Array.from({ length: count }, (_, index) => `${creature} ${last + index + 1}`);
+}
+/** The turn after the current one, and the round: after the last in the order comes the first, in the next round. */
+export function nextTurn(order, turn, round) {
+    const index = turn === undefined ? -1 : order.findIndex((name) => comparableText(name) === comparableText(turn));
+    return index === order.length - 1 ? { turn: order[0], round: round + 1 } : { turn: order[index + 1], round };
+}

package/dist/systems/game-system.d.ts

@@ -0,0 +1,236 @@
+import { type FieldKind } from "../core/field-kind.ts";
+import { type Formula, type SystemFormulas } from "../core/formula.ts";
+import { type ImperialUnits } from "../core/length.ts";
+import type { ProgressionRule } from "../core/progression-rule.ts";
+/** The file that makes a folder a game system and says what it is. */
+export declare const systemFileName = "system.yaml";
+/** A recipe of the system (D-185, DAT-4): the fields it brings to their maximum or to a value, the occasions it ends, the rules to read for the rest. */
+export interface Recipe {
+    name: string;
+    /** By field, "max" or a value; a field ending in * stands for every field that begins so, such as slots-*. */
+    set: Record<string, "max" | number>;
+    /** By field, or by fields that begin so, how many come back in all, such as half the hit dice (DAT-4). */
+    regain: Record<string, Formula>;
+    ends: string[];
+    rules: string[];
+}
+/** What can break what someone keeps alive (D-266, EFF-14): their counter going down, the conditions they may take, and the title of the rule to read. */
+export interface Keeping {
+    counter: string;
+    conditions: string[];
+    rules: string;
+}
+/** What a fight follows on the dashboard's Combat (D-314): each one's counter, whether the player hears a foe's in words, and the conditions that keep from acting. */
+export interface CombatData {
+    track: string;
+    inWords: boolean;
+    inactive: string[];
+}
+/** When the dashboard shows the panel of the dying, and its counters (D-314): at a counter's value, such as hp 0. */
+export interface Dying {
+    field: string;
+    value: number;
+    show: string[];
+}
+/** A threshold (D-184, DAT-3): a field, the value at which it matters, or none for every change, and the title of the rule to read. */
+export interface Threshold {
+    field: string;
+    value?: number;
+    rule: string;
+}
+/** A group of the character sheet (D-207, DAT-2): its name, which show takes as Page#Group, its fields in order, and what write says of it when a character joins the party. */
+export interface SheetGroup {
+    name: string;
+    entries: SheetEntry[];
+    note?: string;
+    /** Its icon on the dashboard: the d of an SVG path on a grid of 24, drawn as a line (D-284). */
+    icon?: string;
+}
+/** A field of the sheet; one written only when it applies is never reminded (D-206); beside, a field shown next to it, such as str-mod by str. */
+export interface SheetEntry {
+    field: string;
+    optional: boolean;
+    beside?: string;
+}
+/** A setting the setup asks for the system (D-212, DAT-10): its values, each with what it means and the fields it leaves out of the sheet. */
+export interface SystemSetting {
+    name: string;
+    /** What it is to the player, in a few words, as the setup asks it (D-370). */
+    about?: string;
+    /** Each value with what it means to the master, and to the player when the system says it, as the dashboard shows it (D-341). */
+    values: {
+        value: string;
+        means: string;
+        player?: string;
+        without: string[];
+    }[];
+}
+/** What the creatures overcome in a scene give the party (DAT-11): the field of the party, the creatures' field that gives it, and the counter at which one is overcome. */
+export interface Reward {
+    field: string;
+    from: string;
+    counter: string;
+    value: number;
+}
+/** How one travels in the game (TRV-1–TRV-3, TRV-8): its paces, the hours of a day's travel, what terrain does to a pace, the kinds of road. */
+export interface Travel {
+    /** By name, the distance of an hour, in metres. */
+    paces: Record<string, number>;
+    /** The pace used when none is given: the one the system names, else the first. */
+    pace?: string;
+    /** How many hours one travels in a day; beyond them, the rule `beyond` says what happens. */
+    hours?: number;
+    /** The title of the rule that tells what each pace does. */
+    rule?: string;
+    beyond?: string;
+    /** By value of the environment's terrain entry, what it multiplies the speed of a pace by. */
+    terrain: Record<string, number>;
+    kinds: TravelKind[];
+}
+/** A kind of road (D-260, TRV-2): travelled at a pace, or only in a vehicle that has a field with a value, at the speed its field holds; its hours of a day; its current, downstream. */
+export interface TravelKind {
+    name: string;
+    vehicle?: {
+        field: string;
+        value: string;
+        speed: string;
+    };
+    hours?: number;
+    /** Metres an hour, added going downstream. */
+    current?: number;
+}
+/**
+ * How a game counts on the map of a place (GRD-4, GRD-5): a square in metres, a diagonal step in squares, the factor of difficult ground, the fields that give
+ * the speed and the size, the side in squares of each size larger than one, and the rule to read when one leaves the side of another.
+ */
+export interface GridRules {
+    square: number;
+    diagonal: number;
+    difficult: number;
+    speed: string;
+    size?: string;
+    footprints: Record<string, number>;
+    leaving?: string;
+}
+/** An installed game system: what it is and what it declares (SYS-1). */
+export interface GameSystem {
+    /** The name a campaign gives as its system: the folder's name, such as 5e. */
+    name: string;
+    /** The folder that holds its system.yaml and its pages. */
+    folder: string;
+    /** What it is, for messages: "the fifth edition, from the SRD 5.1". */
+    title: string;
+    /** The language it names its pages in, as a code such as en. */
+    language: string;
+    /** What a work that uses it must say of its source, when its license asks for it. */
+    attribution?: string;
+    /** The kind of each field it declares (SYS-8). */
+    fields: Record<string, FieldKind>;
+    /** Its coins, as config takes them, "gp 100, sp 10, cp 1", or as campaign.yaml writes them (D-182, DAT-1). */
+    coins?: string | Record<string, unknown>;
+    /** How long a round lasts, in seconds (D-187, DAT-7). */
+    roundSeconds?: number;
+    /** How many metres its mile and foot are worth, when it has its own (D-262): outputs in imperial use them. */
+    imperial?: ImperialUnits;
+    /** How one travels, when the game says so (D-261, TRV-1). */
+    travel?: Travel;
+    /** How the map of a place counts, when the game has one (GRD-4). */
+    grid?: GridRules;
+    /** The groups of a character sheet, in order (D-183, D-207, DAT-2). */
+    sheet: SheetGroup[];
+    /** By field, the dice a number of the sheet is rolled with, for the dashboard's free roll (D-280), such as 1d20 by insight. */
+    sheetDice: Record<string, string>;
+    /** The line under a character's name on the dashboard, with fields in braces, such as Level {level} {classes} (D-288). */
+    sheetHeadline?: string;
+    /** The icon on the token of one of the party (D-414): by the name of the first item of a field that has one, such as a class of classes. */
+    tokenIcons?: {
+        field: string;
+        icons: Record<string, string>;
+    };
+    /** The names the game gives some rolls, by their dice as rollName reads them, and by language: 2d20kh1, with advantage (D-399). */
+    rollNames: Record<string, Record<string, string>>;
+    /** Where the dashboard puts the groups of the sheet (D-295): those of its rail, in order, the order of the others, and the fields and groups at hand in a fight (D-315). */
+    sheetCards?: {
+        rail: string[];
+        order: string[];
+        atHand: string[];
+    };
+    /** The names a list field accepts, by field, such as the skills of save-proficiencies (SYS-8). */
+    values: Record<string, string[]>;
+    /** The lists whose items mark a number of the sheet that reads them, such as a proficiency (D-217, DAT-2). */
+    marks: string[];
+    /** The fields the line of a character shows, in order; whenSet marks a field usually at zero, shown only when it is not (DAT-2, DAT-4). */
+    statusLine: {
+        field: string;
+        whenSet: boolean;
+    }[];
+    thresholds: Threshold[];
+    recipes: Recipe[];
+    /** The names of its conditions (D-186, DAT-6). */
+    conditions: string[];
+    /** By condition, its drawing on a token and in Combat (D-419): the d of an SVG path on a grid of 24. */
+    conditionIcons: Record<string, string>;
+    /** What can break what someone keeps alive, when the game has it (EFF-14). */
+    keeping?: Keeping;
+    /** What a fight follows on the dashboard (D-314). */
+    combat?: CombatData;
+    /** The panel of the dying on the dashboard (D-314). */
+    dying?: Dying;
+    /** By counter, the counter it shields, which loses from it first, as temp-hp shields hp (DAT-14). */
+    shields: Record<string, string>;
+    /** What it works out from the fields of a page (D-199, FOR-1). */
+    formulas: SystemFormulas;
+    /** How the classes of a character give the rows of their tables and their features (D-219, PRO-1–PRO-3). */
+    progression?: ProgressionRule;
+    /** By list, the fields whose value on the page of each item is a formula worked out on who lists it, as a class's spell-save-dc or an armor's armor-class (PRO-5). */
+    itemFormulas: Record<string, string[]>;
+    /** By list, the pages every character who keeps the sheet has in it without writing them, as the unarmed strike in equipped (DAT-13, D-235). */
+    alwaysIn: Record<string, string[]>;
+    /** The counters that come back with a rest, by name or by a name ending in *: a character has them full until it spends them (DAT-9). */
+    uses: string[];
+    /** The settings it adds to the setup (DAT-10). */
+    settings: SystemSetting[];
+    /** The fields the campaign's settings leave out, as xp with milestones (DAT-10). */
+    leftOut: string[];
+    /** What the creatures overcome in a scene give the party (DAT-11). */
+    rewards: Reward[];
+    /**
+     * Its parts of the master's instructions, by name, from instructions/<part>.md: each adds to the core's part of that name, such as creation or fight, or takes
+     * its place when its frontmatter says replace: true (D-121).
+     */
+    parts: Record<string, InstructionPart>;
+}
+/** A part of the master's instructions as a layer gives it: its text, and whether it takes the place of the layers below instead of adding to them (D-121). */
+export interface InstructionPart {
+    text: string;
+    replace: boolean;
+}
+/**
+ * The system as a campaign plays it, with the values its settings have (DAT-10): the fields a value leaves out are gone from the sheet, the line, the experience
+ * and the rewards. A setting without a value, or with one the system lacks, leaves out nothing.
+ */
+export declare function withSettings(system: GameSystem, valueOf: (setting: string) => string | undefined): GameSystem;
+/**
+ * The name the game gives a roll of these dice, in the language asked, else in the system's (D-399): 2d20kh1, or 2d20dl1, is "with advantage" in 5e; undefined
+ * when the game names it not, or the dice are more than one kind.
+ */
+export declare function rollName(system: GameSystem, dice: string, language: string): string | undefined;
+/** The systems installed in these folders, nearest folder first: each folder in them with a system.yaml. A name found twice is the nearest one. */
+export declare function installedSystems(folders: string[]): GameSystem[];
+/** What a campaign may add to its game system in campaign.yaml (CAM-1): its own fields, tables, formulas, counters, recipes, line of the player character and travel. */
+export declare const campaignDataNames: readonly ["fields", "tables", "computed", "counters", "recipes", "status-line", "travel"];
+/** What campaign.yaml adds to the game system, as it writes it: checked when the system is read with it (CAM-3). */
+export type CampaignData = Partial<Record<(typeof campaignDataNames)[number], unknown>>;
+/**
+ * The installed system with what the campaign adds to it, the nearest layer winning (CAM-2); when the additions do not read, the system alone and why (CAM-3).
+ * Undefined as a system when none is installed by that name.
+ */
+export declare function findCampaignSystem(folders: string[], name: string, data: CampaignData): {
+    system?: GameSystem;
+    problem?: string;
+};
+/**
+ * The installed system with this name, ignoring case, from the nearest folder that has it, with what a campaign adds to it; undefined when none is. Only its own
+ * system.yaml is read.
+ */
+export declare function findSystem(folders: string[], name: string, data?: CampaignData): GameSystem | undefined;