rpg-engine 0.0.0-stage → 0.1.1

package/dist/commands/game-roads.d.ts

@@ -0,0 +1,90 @@
+import { type ImperialUnits, type UnitSystem } from "../core/length.ts";
+import type { Problem } from "../core/problem.ts";
+import { type Speed, type Start, type Step, type Stretch, type Way } from "../map/index.ts";
+import { type Page, type World } from "../pages/index.ts";
+import type { GameSystem, TravelKind } from "../systems/index.ts";
+/** The roads of the world (ROA-4): their stretches, in the order of the pages and of their stops; the page of each road by its name; the names of the stops. */
+export interface Roads {
+    stretches: Stretch[];
+    pages: Map<string, Page>;
+    stops: Set<string>;
+}
+/** How the travellers go (TRV-1, TRV-2, TRV-6): at a pace, a speed of metres an hour with its name when the system gives it, and in a vehicle, when they are in one. */
+export interface Going {
+    pace?: {
+        name?: string;
+        speed: number;
+    };
+    vehicle?: Page;
+}
+/** How the story measures (D-262): the campaign's units, and what the game's mile and foot are worth. */
+export interface Measures {
+    units: UnitSystem;
+    imperial: ImperialUnits;
+}
+/** The roads of the world (ROA-1, ROA-4): every place of the campaign with stops that read; a stretch counts only between two places of the campaign. */
+export declare function roadsOf(world: World): Roads;
+/**
+ * Who travels when no one is named (TRV-6): the living members of the party who are in the same place as the player character, the character first; in no place,
+ * those in the same vehicle, or else those of the journey that stopped in the open, never one who was simply never put anywhere.
+ */
+export declare function travellingParty(world: World, character: Page | undefined, journeyMovers: string[]): Page[];
+/**
+ * What moves for the travellers (TRV-6): the vehicle they are all in, the outermost item that holds them below a place, or themselves. Refused when some are in
+ * a vehicle and some are not, or they are in different ones, or in different places.
+ */
+export declare function moversOf(world: World, travellers: Page[]): {
+    movers: Page[];
+    vehicle?: Page;
+};
+/** The stop a journey starts from or ends at (ROA-5): the nearest page of the chain of `page`, itself first, that is a stop of a road. */
+export declare function stopOf(world: World, roads: Roads, page: Page): Page | undefined;
+/** The outer of two places that are one spot for a journey (ROA-5): the same, or one inside the other; undefined when they are not. */
+export declare function sameSpot(world: World, first: Page, second: Page): Page | undefined;
+/**
+ * Why a page is on a road, when no journey says where along it (TRV-9): the road holds it, as after a move by hand; undefined when its place is no road.
+ * Its stops are what to give as where it starts.
+ */
+export declare function unknownOnRoad(world: World, roads: Roads, page: Page): string | undefined;
+/** The kind of a road (ROA-2), as its `kind` names it, road when it has none; and what the system says of it, nothing for a kind it does not know. */
+export declare function kindOf(system: GameSystem | undefined, road: Page): {
+    name: string;
+    kind?: TravelKind;
+};
+/**
+ * How many metres a minute one goes along each stretch (TRV-2, TRV-3): in a vehicle on a kind it travels, at its speed, with the current going downstream; at the
+ * pace on the others, with the road's terrain, but not in a vehicle that only travels other kinds. Undefined where one cannot go.
+ */
+export declare function speedOf(world: World, system: GameSystem | undefined, roads: Roads, going: Going): Speed;
+/** The quickest way from a start to a stop for those who go so (TRV-4). */
+export declare function wayFor(world: World, system: GameSystem | undefined, roads: Roads, start: Start, goal: Page, going: Going): Way | undefined;
+/**
+ * Why no way leads to the goal for those who go so (TRV-4): the kinds of road a way would need, when one exists for another way of going, such as by river in a
+ * vehicle; else that no road joins them.
+ */
+export declare function noWayText(world: World, system: GameSystem | undefined, roads: Roads, start: Start, goal: Page, going: Going): string;
+/** The pace or speed those who go use (TRV-1): one of the system's paces by name, or a speed; without either, the system's own. Refused when it is neither, or when there is none. */
+export declare function paceOf(system: GameSystem | undefined, written: string | undefined, vehicle: Page | undefined): Going["pace"];
+/** The hours one travels in a day (TRV-8): those given, else those of the kind of the first stretch in a vehicle, else the system's, else 8. */
+export declare function dayHours(system: GameSystem | undefined, roads: Roads, way: Way, going: Going, given: number | undefined): number;
+/** The measures of the story (D-262): the campaign's units, metric when it has none, with the system's mile and foot, else the true ones. */
+export declare function measuresOf(root: string, system: GameSystem | undefined): Measures;
+export declare function lengthText(metres: number, measures: Measures): string;
+/** "at a normal pace (3 miles an hour)", "at 4.5 km an hour", "in Chiatta, at its speed": how they go, for outputs. */
+export declare function goingText(world: World, system: GameSystem | undefined, going: Going, measures: Measures): string;
+/** The stop a step ends at. */
+export declare function stepEnd(step: Step): string;
+/** "Guadoscuro → Bivio → Rocca, 36 km by Strada vecchia (12 km) and Sentiero dei colli (24 km)": a way from where it starts, with its roads in order. */
+export declare function wayText(way: Way, from: string, measures: Measures): string;
+/** "7h 30m of travel", and when it takes more than a day's hours, "2 days at 8 h a day". */
+export declare function durationText(minutes: number, hours: number): string;
+/** A time in hours and minutes, never days, as travel counts it: 24h 40m, 45m. */
+export declare function hoursText(minutes: number): string;
+/** A road whose kind the system does not know (ROA-2, ROA-7): it is travelled as a road, which may not be what the campaign meant. Nothing without travel in the system. */
+export declare function roadProblems(world: World, system: GameSystem | undefined): Problem[];
+/** The roads between places of different maps that are not passages (ROA-8): a road stays on one map, a passage joins two. */
+export declare function passageProblems(world: World, system: GameSystem | undefined): Problem[];
+/** Whether a vehicle travels only the kinds of road that are travelled in it, as a boat (TRV-2): some kind names it; a cart, which none names, goes at the pace. */
+export declare function isVehicleOnly(world: World, system: GameSystem | undefined, vehicle: Page): boolean;
+/** What the terrain of a road or a region does to a pace (TRV-3, TRV-12): the factor the system gives the value of the terrain entry of its environment, 1 for any other. */
+export declare function terrainFactor(world: World, system: GameSystem | undefined, road: Page): number;

package/dist/commands/game-roads.js

@@ -0,0 +1,284 @@
+// Roads in play (D-256, D-260, D-262): the roads of the world as stretches, the stop a journey starts or ends at, how fast one goes on each stretch, the quickest
+// way, and the measures in the player's units.
+import { readTextSetting, unitSystems } from "../campaign/index.js";
+import { formatLength, formatSpeed, readSpeed, speedHelp, trueImperialUnits } from "../core/length.js";
+import { comparableText, sameName } from "../core/text.js";
+import { quickestWay, stretchesOf } from "../map/index.js";
+import { environmentAt, isEmptyField, isInParty, locate, pagesWithName, readStops } from "../pages/index.js";
+import { effectiveFields } from "./effect-layer.js";
+import { mapKey } from "./game-maps.js";
+/** The roads of the world (ROA-1, ROA-4): every place of the campaign with stops that read; a stretch counts only between two places of the campaign. */
+export function roadsOf(world) {
+    let roads = known.get(world);
+    if (roads === undefined) {
+        roads = readRoads(world);
+        known.set(world, roads);
+    }
+    return roads;
+}
+const known = new WeakMap();
+/**
+ * Who travels when no one is named (TRV-6): the living members of the party who are in the same place as the player character, the character first; in no place,
+ * those in the same vehicle, or else those of the journey that stopped in the open, never one who was simply never put anywhere.
+ */
+export function travellingParty(world, character, journeyMovers) {
+    if (character === undefined) {
+        return [];
+    }
+    const place = placeOf(world, character);
+    const outer = locate(world, character).chain.at(-1);
+    const together = (page) => {
+        if (place !== undefined) {
+            return placeOf(world, page) === place;
+        }
+        const chain = locate(world, page).chain;
+        return outer !== undefined ? chain.at(-1) === outer : chain.length === 0 && journeyMovers.some((name) => comparableText(name) === comparableText(page.name));
+    };
+    return [character, ...world.pages.filter((page) => page !== character && isInParty(page) && together(page))];
+}
+/**
+ * What moves for the travellers (TRV-6): the vehicle they are all in, the outermost item that holds them below a place, or themselves. Refused when some are in
+ * a vehicle and some are not, or they are in different ones, or in different places.
+ */
+export function moversOf(world, travellers) {
+    const vehicles = travellers.map((page) => locate(world, page).chain.filter((holder, index, chain) => holder.type === "item" && chain.slice(0, index).every((inner) => inner.type === "item")).at(-1));
+    const places = new Set(travellers.map((page) => placeOf(world, page)));
+    if (places.size > 1) {
+        throw new Error(`${travellers.map((page) => page.name).join(", ")} are not in the same place: a journey starts from one place. Move them together first, or travel with each apart. Nothing changed.`);
+    }
+    if (vehicles.every((vehicle) => vehicle === undefined)) {
+        return { movers: travellers };
+    }
+    const vehicle = vehicles[0];
+    if (vehicle === undefined || vehicles.some((other) => other !== vehicle)) {
+        const aboard = travellers.filter((_, index) => vehicles[index] !== undefined).map((page) => page.name);
+        throw new Error(`${aboard.join(", ")} ${aboard.length === 1 ? "is" : "are"} in a vehicle, and the others are not: move them all into the same one, or all out of it. Nothing changed.`);
+    }
+    return { movers: [vehicle], vehicle };
+}
+/** The stop a journey starts from or ends at (ROA-5): the nearest page of the chain of `page`, itself first, that is a stop of a road. */
+export function stopOf(world, roads, page) {
+    return [page, ...locate(world, page).chain].find((holder) => roads.stops.has(holder.name));
+}
+/** The outer of two places that are one spot for a journey (ROA-5): the same, or one inside the other; undefined when they are not. */
+export function sameSpot(world, first, second) {
+    return first === second || locate(world, first).chain.includes(second) ? second : locate(world, second).chain.includes(first) ? first : undefined;
+}
+/**
+ * Why a page is on a road, when no journey says where along it (TRV-9): the road holds it, as after a move by hand; undefined when its place is no road.
+ * Its stops are what to give as where it starts.
+ */
+export function unknownOnRoad(world, roads, page) {
+    const place = placeOf(world, page);
+    const road = place === undefined ? undefined : roads.pages.get(place.name);
+    if (road === undefined) {
+        return undefined;
+    }
+    const stops = [...new Set(roads.stretches.filter((stretch) => stretch.road === road.name).flatMap((stretch) => [stretch.from, stretch.to]))];
+    return `${page.name} is on ${road.name}, but no journey says where along it: give from, the stop they last passed or the nearest one (${stops.join(", ")}).`;
+}
+/** The kind of a road (ROA-2), as its `kind` names it, road when it has none; and what the system says of it, nothing for a kind it does not know. */
+export function kindOf(system, road) {
+    const name = typeof road.fields.kind === "string" && !isEmptyField(road.fields.kind) ? road.fields.kind.trim() : "road";
+    return { name, kind: system?.travel?.kinds.find((kind) => comparableText(kind.name) === comparableText(name)) };
+}
+/**
+ * How many metres a minute one goes along each stretch (TRV-2, TRV-3): in a vehicle on a kind it travels, at its speed, with the current going downstream; at the
+ * pace on the others, with the road's terrain, but not in a vehicle that only travels other kinds. Undefined where one cannot go.
+ */
+export function speedOf(world, system, roads, going) {
+    const vehicleOnly = going.vehicle !== undefined && isVehicleOnly(world, system, going.vehicle);
+    return (stretch, forward) => {
+        const road = roads.pages.get(stretch.road);
+        if (road === undefined) {
+            return undefined;
+        }
+        const { kind } = kindOf(system, road);
+        if (kind?.vehicle !== undefined) {
+            const speed = going.vehicle === undefined || !carries(world, going.vehicle, kind) ? undefined : vehicleSpeed(world, going.vehicle, kind);
+            const current = forward ? (readSpeed(road.fields.current) ?? kind.current ?? 0) : 0;
+            return speed === undefined ? undefined : (speed + current) / 60;
+        }
+        return vehicleOnly || going.pace === undefined ? undefined : (going.pace.speed * terrainFactor(world, system, road)) / 60;
+    };
+}
+/** The quickest way from a start to a stop for those who go so (TRV-4). */
+export function wayFor(world, system, roads, start, goal, going) {
+    return quickestWay(roads.stretches, start, goal.name, speedOf(world, system, roads, going));
+}
+/**
+ * Why no way leads to the goal for those who go so (TRV-4): the kinds of road a way would need, when one exists for another way of going, such as by river in a
+ * vehicle; else that no road joins them.
+ */
+export function noWayText(world, system, roads, start, goal, going) {
+    const any = quickestWay(roads.stretches, start, goal.name, () => 1);
+    if (any === undefined) {
+        return `No road leads to ${goal.name} from there: write one, a place with stops, such as write "Strada del passo", type place, set stops=[[A]], 8 km, [[${goal.name}]].`;
+    }
+    const usable = speedOf(world, system, roads, going);
+    const needed = [...new Set(any.steps.filter((step) => usable(step.stretch, step.forward) === undefined).map((step) => kindText(system, roads.pages.get(step.stretch.road))))];
+    const how = going.vehicle === undefined ? "on foot" : `in ${going.vehicle.name}`;
+    return `No way leads to ${goal.name} ${how}: the roads that join them include ${needed.join(", ")}.`;
+}
+/** The pace or speed those who go use (TRV-1): one of the system's paces by name, or a speed; without either, the system's own. Refused when it is neither, or when there is none. */
+export function paceOf(system, written, vehicle) {
+    const paces = system?.travel?.paces ?? {};
+    if (written !== undefined && written.trim() !== "") {
+        const name = sameName(Object.keys(paces), written.trim());
+        const speed = name === undefined ? readSpeed(written) : paces[name];
+        if (speed === undefined) {
+            const known = Object.keys(paces).length === 0 ? "" : `one of the paces of the game (${Object.keys(paces).join(", ")}) or `;
+            throw new Error(`"${written}" is not a pace: give ${known}${speedHelp}.`);
+        }
+        return { name, speed };
+    }
+    const own = system?.travel?.pace;
+    if (own !== undefined && paces[own] !== undefined) {
+        return { name: own, speed: paces[own] };
+    }
+    if (vehicle === undefined) {
+        throw new Error(`The game system gives no pace for travel: give pace as ${speedHelp}.`);
+    }
+    return undefined;
+}
+/** The hours one travels in a day (TRV-8): those given, else those of the kind of the first stretch in a vehicle, else the system's, else 8. */
+export function dayHours(system, roads, way, going, given) {
+    const first = way.steps[0] === undefined ? undefined : roads.pages.get(way.steps[0].stretch.road);
+    const kind = going.vehicle === undefined || first === undefined ? undefined : kindOf(system, first).kind;
+    return given ?? kind?.hours ?? system?.travel?.hours ?? 8;
+}
+/** The measures of the story (D-262): the campaign's units, metric when it has none, with the system's mile and foot, else the true ones. */
+export function measuresOf(root, system) {
+    const written = readTextSetting(root, "units");
+    const units = unitSystems.find((name) => written !== undefined && comparableText(name) === comparableText(written)) ?? "metric";
+    return { units, imperial: system?.imperial ?? trueImperialUnits };
+}
+export function lengthText(metres, measures) {
+    return formatLength(metres, measures.units, measures.imperial);
+}
+/** "at a normal pace (3 miles an hour)", "at 4.5 km an hour", "in Chiatta, at its speed": how they go, for outputs. */
+export function goingText(world, system, going, measures) {
+    if (going.vehicle !== undefined && (going.pace === undefined || isVehicleOnly(world, system, going.vehicle))) {
+        return `in ${going.vehicle.name}, at its speed`;
+    }
+    const speed = going.pace === undefined ? "" : formatSpeed(going.pace.speed, measures.units, measures.imperial);
+    const pace = going.pace?.name === undefined ? `at ${speed}` : `at a ${going.pace.name} pace (${speed})`;
+    return going.vehicle === undefined ? pace : `in ${going.vehicle.name}, ${pace}`;
+}
+/** The stop a step ends at. */
+export function stepEnd(step) {
+    return step.forward ? step.stretch.to : step.stretch.from;
+}
+/** "Guadoscuro → Bivio → Rocca, 36 km by Strada vecchia (12 km) and Sentiero dei colli (24 km)": a way from where it starts, with its roads in order. */
+export function wayText(way, from, measures) {
+    const legs = [];
+    for (const step of way.steps) {
+        const last = legs.at(-1);
+        if (last?.road === step.stretch.road) {
+            last.length += step.length;
+        }
+        else {
+            legs.push({ road: step.stretch.road, length: step.length });
+        }
+    }
+    const roads = legs.map((leg) => (legs.length === 1 ? leg.road : `${leg.road} (${lengthText(leg.length, measures)})`));
+    const by = roads.length === 1 ? roads[0] : `${roads.slice(0, -1).join(", ")} and ${roads.at(-1)}`;
+    return `${[from, ...way.steps.map(stepEnd)].join(" → ")}, ${lengthText(way.length, measures)} by ${by}`;
+}
+/** "7h 30m of travel", and when it takes more than a day's hours, "2 days at 8 h a day". */
+export function durationText(minutes, hours) {
+    const days = Math.ceil(minutes / (hours * 60) - 1e-9);
+    return `${hoursText(Math.round(minutes))} of travel${days > 1 ? `, ${days} days at ${hours} h a day` : ""}`;
+}
+/** A time in hours and minutes, never days, as travel counts it: 24h 40m, 45m. */
+export function hoursText(minutes) {
+    const [hours, rest] = [Math.floor(minutes / 60), minutes % 60];
+    return [hours > 0 ? `${hours}h` : "", rest > 0 || hours === 0 ? `${rest}m` : ""].filter((part) => part !== "").join(" ");
+}
+/** A road whose kind the system does not know (ROA-2, ROA-7): it is travelled as a road, which may not be what the campaign meant. Nothing without travel in the system. */
+export function roadProblems(world, system) {
+    const kinds = system?.travel?.kinds ?? [];
+    if (kinds.length === 0) {
+        return [];
+    }
+    return [...roadsOf(world).pages.values()].flatMap((road) => {
+        const { name, kind } = kindOf(system, road);
+        // A road and a passage between maps are the engine's own kinds (ROA-2, ROA-8).
+        return kind !== undefined || name === "road" || name === "portal"
+            ? []
+            : [{
+                    path: road.path,
+                    message: `${road.name} has kind ${name}, which the game system does not know: it is travelled as a road.`,
+                    fix: `write ${road.name}, set kind to one of ${kinds.map((known) => known.name).join(", ")}, or add the kind to the campaign with config travel`,
+                }];
+    });
+}
+/** The roads between places of different maps that are not passages (ROA-8): a road stays on one map, a passage joins two. */
+export function passageProblems(world, system) {
+    return [...roadsOf(world).pages.values()].flatMap((road) => {
+        const stops = roadsOf(world).stretches.filter((stretch) => stretch.road === road.name).flatMap((stretch) => [stretch.from, stretch.to]);
+        const maps = new Set(stops.map((name) => pagesWithName(world, name)[0]).filter((page) => page !== undefined).map((page) => mapKey(world, page)));
+        return maps.size < 2 || kindOf(system, road).name === "portal"
+            ? []
+            : [{ path: road.path, message: `${road.name} joins places of different maps, as only a passage does.`, fix: `write ${road.name}, set kind=portal, if it is one; else move its stops onto one map` }];
+    });
+}
+/** The nearest place of a page's chain, itself first. */
+function placeOf(world, page) {
+    return [page, ...locate(world, page).chain].find((holder) => holder.type === "place");
+}
+function readRoads(world) {
+    const stretches = [];
+    const pages = new Map();
+    const stops = new Set();
+    const placeNamed = (name) => {
+        const found = pagesWithName(world, name);
+        return found.length === 1 && found[0].type === "place" && found[0].system === undefined ? found[0] : undefined;
+    };
+    for (const road of world.pages.filter((page) => page.type === "place" && page.system === undefined && !isEmptyField(page.fields.stops))) {
+        const read = readStops(road.fields.stops);
+        if ("problem" in read) {
+            continue;
+        }
+        const names = read.stops.map((name) => placeNamed(name)?.name ?? "");
+        const own = stretchesOf(road.name, names, read.lengths).filter((stretch) => stretch.from !== "" && stretch.to !== "");
+        pages.set(road.name, road);
+        stretches.push(...own);
+        own.forEach((stretch) => stops.add(stretch.from).add(stretch.to));
+    }
+    return { stretches, pages, stops };
+}
+/** Whether a vehicle travels only the kinds of road that are travelled in it, as a boat (TRV-2): some kind names it; a cart, which none names, goes at the pace. */
+export function isVehicleOnly(world, system, vehicle) {
+    return (system?.travel?.kinds ?? []).some((kind) => carries(world, vehicle, kind));
+}
+/** Whether a vehicle is one a kind of road is travelled in (TRV-2): it has the field with the value the system names. */
+function carries(world, vehicle, kind) {
+    if (vehicle === undefined || kind.vehicle === undefined) {
+        return false;
+    }
+    const fields = effectiveFields(world, vehicle);
+    const field = sameName(Object.keys(fields), kind.vehicle.field);
+    const value = field === undefined ? undefined : fields[field];
+    return typeof value === "string" && comparableText(value) === comparableText(kind.vehicle.value);
+}
+function vehicleSpeed(world, vehicle, kind) {
+    const fields = effectiveFields(world, vehicle);
+    const field = kind.vehicle === undefined ? undefined : sameName(Object.keys(fields), kind.vehicle.speed);
+    return field === undefined ? undefined : readSpeed(fields[field]);
+}
+/** What the terrain of a road or a region does to a pace (TRV-3, TRV-12): the factor the system gives the value of the terrain entry of its environment, 1 for any other. */
+export function terrainFactor(world, system, road) {
+    const terrain = environmentAt(world, road).find(({ entry }) => comparableText(entry.name) === "terrain")?.entry.value;
+    const factors = system?.travel?.terrain ?? {};
+    const value = terrain === undefined ? undefined : sameName(Object.keys(factors), terrain);
+    return value === undefined ? 1 : factors[value];
+}
+/** "Fiume Nero, a river travelled in a waterborne vehicle": a road and what it needs. */
+function kindText(system, road) {
+    if (road === undefined) {
+        return "a road";
+    }
+    const { name, kind } = kindOf(system, road);
+    return kind?.vehicle === undefined ? `${road.name}, a ${name}` : `${road.name}, a ${name} travelled only in a vehicle with ${kind.vehicle.field} ${kind.vehicle.value}`;
+}

package/dist/commands/game-rules.d.ts

@@ -0,0 +1,17 @@
+import type { GameSystem } from "../systems/index.ts";
+/** The source of the campaign's own rules, in the campaign's rules folder. */
+export declare const houseRules = "house rules";
+/** What to do when a precedent and the book disagree (D-181). */
+export declare const disagreementAdvice = "When the text and a precedent disagree, tell the player and ask whether to keep the precedent: if so, write it again saying it is a house rule, against the book; if not, remove it. Both with config.";
+/** A rule found by its title: where it comes from, "house rules" or the game system's name, its text, and the precedents about it. */
+export interface TitledRule {
+    source: string;
+    text: string;
+    precedents: string[];
+}
+/** The rule with this title: a house rule first, else the game system's; undefined when neither has a section so titled. */
+export declare function ruleTitled(root: string, system: GameSystem, title: string): TitledRule | undefined;
+/** "Poisoned is a condition of the system 5e, by a house rule:" and the text, then the precedents on it, with what to do when they disagree with the book. */
+export declare function ruleBlock(rule: TitledRule): string;
+/** The rule a precedent is about: the name before its colon, as in "Poisoned: …" (D-179); undefined when it has none. */
+export declare function precedentRule(precedent: string): string | undefined;

package/dist/commands/game-rules.js

@@ -0,0 +1,30 @@
+// A rule by its title, as rules finds it (D-179, DAT-3, DAT-6): a house rule of the campaign first, else the game system's, with the table's precedents on it.
+import { join } from "node:path";
+import { houseRulesFolderName, readListSetting } from "../campaign/index.js";
+import { comparableText } from "../core/text.js";
+import { isTitled, readRuleBook } from "../rules/index.js";
+/** The source of the campaign's own rules, in the campaign's rules folder. */
+export const houseRules = "house rules";
+/** What to do when a precedent and the book disagree (D-181). */
+export const disagreementAdvice = "When the text and a precedent disagree, tell the player and ask whether to keep the precedent: if so, write it again saying it is a house rule, against the book; if not, remove it. Both with config.";
+/** The rule with this title: a house rule first, else the game system's; undefined when neither has a section so titled. */
+export function ruleTitled(root, system, title) {
+    const titled = (section) => isTitled(section, title);
+    const house = readRuleBook(join(root, houseRulesFolderName), houseRules).find(titled);
+    const section = house ?? readRuleBook(join(system.folder, "rules"), system.name).find(titled);
+    if (section === undefined) {
+        return undefined;
+    }
+    const precedents = readListSetting(root, "precedents").filter((precedent) => comparableText(precedentRule(precedent) ?? "") === comparableText(title));
+    return { source: section.source, text: section.text, precedents };
+}
+/** "Poisoned is a condition of the system 5e, by a house rule:" and the text, then the precedents on it, with what to do when they disagree with the book. */
+export function ruleBlock(rule) {
+    const precedents = rule.precedents.length === 0 ? "" : `\n\nPrecedents of the table: ${rule.precedents.join(" · ")}`;
+    const advice = rule.precedents.length > 0 && rule.source !== houseRules ? `\n${disagreementAdvice}` : "";
+    return `${rule.text}${precedents}${advice}`;
+}
+/** The rule a precedent is about: the name before its colon, as in "Poisoned: …" (D-179); undefined when it has none. */
+export function precedentRule(precedent) {
+    return precedent.includes(":") ? precedent.split(":")[0].trim() : undefined;
+}

package/dist/commands/game-saves.d.ts

@@ -0,0 +1,59 @@
+import { saveModes } from "../campaign/index.ts";
+import type { Context } from "../core/context.ts";
+import { type World } from "../pages/index.ts";
+import { type Save } from "../saves/index.ts";
+/** The folder of the saves, at the top of the campaign. */
+export declare const savesFolderName = ".saves";
+export type SaveMode = (typeof saveModes)[number];
+/** The points the campaign starts over from (D-361): the start of play, with the same character, or before session zero, to make one again. */
+export declare const resetPoints: readonly ["start", "session zero"];
+export type ResetPoint = (typeof resetPoints)[number];
+/** What the master does once the game went back: this chat remembers what is gone, so a new one goes on (D-361). */
+export declare const newChatText: string;
+/** The campaign's mode of saves (SAV-1); checkpoint until the setup asks it. A campaign.yaml that cannot be read stops the command, with how to fix it. */
+export declare function saveMode(root: string): SaveMode;
+/** The saves of the campaign, in order. */
+export declare function campaignSaves(root: string): Save[];
+/** Whether the player character is dead: every one the campaign has, when it has one. Then no save is made, since going back is what one is for (SAV-3). */
+export declare function isPlayerDead(world: World): boolean;
+/** The save whose load stopped halfway, which save load finishes (SAV-5); undefined when none did. */
+export declare function interruptedLoad(root: string): Save | undefined;
+/**
+ * Makes a save, numbered after the last and named by the game date and `label` (SAV-3, SAV-4): the game's files as the disk has them, with the public line of
+ * the save already in the log; the line is written once the zip is. Fails, writing nothing, when the zip cannot be written.
+ */
+export declare function makeSave(root: string, context: Context, label: string | undefined, why: string): Save;
+/**
+ * Gives the campaign back as a save holds it (SAV-5): its game files as they were, but campaign.yaml, its settings, as it is now (D-360), those made since
+ * removed, and the later saves removed; then a public line in the log, and the mark that the chat going on must give way to a new one (D-361). What it removes or rewrites goes first into `before load NNN.zip`, never in place of an older one, so that a load can be undone by hand. A save that
+ * cannot be read, holds a file outside the game's or no campaign.yaml is refused before anything is written; a load that stops halfway leaves its mark, and save
+ * load finishes it. Returns the saves removed and the copy made, none when it finishes a load.
+ */
+export declare function loadSave(root: string, context: Context, save: Save): {
+    removed: Save[];
+    copy?: string;
+};
+/** The save the game went back to, until the player confirms a new chat: the chat that went on before remembers what is gone (D-361, D-362). */
+export declare function wentBackTo(root: string): string | undefined;
+/** The player confirmed a new chat: the game goes on in it (D-362). */
+export declare function newChatBegun(root: string): void;
+/** Why each save was made, by its number, as its line in the log says: start, session zero, scene closed or asked. */
+export declare function savesWhy(root: string): Map<number, string>;
+/**
+ * The save a reset goes back to (D-361): the one before session zero, or the start of play, else, in a campaign older than the start's save, the first one
+ * made after session zero; undefined when there is none.
+ */
+export declare function resetSave(saves: Save[], why: Map<number, string>, to: ResetPoint): Save | undefined;
+/** "3 - day 2, 06.10 - Scontro all'ossario": a save as outputs name it. */
+export declare function saveText(save: Save): string;
+/**
+ * What the death of the last living player character allows (D-55, SAV-7): the save it may go back to, as the mode says, so that the master offers only what
+ * exists; none when campaign.yaml cannot be read, which other outputs say.
+ */
+export declare function deathNotes(root: string, name: string): string[];
+/** Whether a path is one of the game's files: in the campaign, not the host's nor under a name with a dot at its top (SAV-2). */
+export declare function isGameFile(root: string, path: string): boolean;
+/** What loading may do under each mode of saves (D-55); reset, back to the start, in every mode (D-359). */
+export declare function loadRule(mode: SaveMode): string;
+/** Why the mode of saves does not allow going back to a save (D-55): permadeath never, checkpoint only to the last and once the player character is dead; undefined when it may. */
+export declare function loadRefusal(mode: SaveMode, saves: Save[], chosen: Save, dead: boolean): string | undefined;