rpg-engine 0.0.0-stage → 0.1.1

package/dist/pages/rename-page.js

@@ -0,0 +1,109 @@
+// A page renamed with what points to it (D-417): its file moves beside itself, and every link to it in the campaign's pages follows, with its section and its
+// words, as Obsidian does; the old name stays among its aliases, so that what keeps it as it was, as the log, still finds it.
+import { dirname, join } from "node:path";
+import { files } from "../core/store.js";
+import { comparableText } from "../core/text.js";
+import { changeFields, joinPageFile, readFields, splitPageFile } from "./page-file.js";
+import { checkPageName, otherPagesWithAlias, pagesWithName, systemPageNamed, textsIn } from "./world.js";
+/**
+ * Plans the rename of a page of the campaign and of every link to it in the campaign's pages, writing nothing; refused for a page of the game system, a name
+ * or an alias another page has, or a name that would leave a frontmatter unreadable. A rename stopped half way is planned again, to finish it.
+ */
+export function planRename(world, page, to) {
+    checkPageName(to);
+    if (page.system !== undefined) {
+        throw new Error(`${page.name} is a page of the game system ${page.system}: read-only, it keeps its name. Nothing changed.`);
+    }
+    const path = join(dirname(page.path), `${to}.md`).split("\\").join("/");
+    // The new page a rename stopped half way already wrote, with the old name among its aliases, is no other page.
+    const halfDone = (other) => other.path === path && textsIn(other.fields.aliases).some((alias) => comparableText(alias.trim()) === comparableText(page.name));
+    const taken = pagesWithName(world, to).find((other) => other !== page && !halfDone(other)) ?? systemPageNamed(world, to);
+    if (taken !== undefined) {
+        throw new Error(`${taken.name} is already a page${taken.system === undefined ? "" : ` of the game system ${taken.system}`}: give ${page.name} a name no page has. Nothing changed.`);
+    }
+    const aliased = otherPagesWithAlias(world, page, to).filter((other) => !halfDone(other));
+    if (aliased.length > 0) {
+        const holders = aliased.map((other) => other.name).join(" and ");
+        throw new Error(`${to} is an alias of ${holders}, whose links would lead to ${page.name}: give ${page.name} another name, or first take ${to} out of the aliases of ${holders} with write ${aliased[0].name} --remove aliases=${to}. Nothing changed.`);
+    }
+    // One of two pages with the same name, given by its path: the links to that name are left to the other, which keeps it.
+    const kept = pagesWithName(world, page.name).find((other) => other !== page);
+    const edited = world.pages.filter((other) => other.system === undefined).flatMap((other) => {
+        const full = join(world.root, other.path);
+        const text = files().fresh(full) ?? "";
+        const { renamed, count } = kept === undefined ? renamedLinks(text, page.name, to) : { renamed: text, count: 0 };
+        if (count > 0 && isReadable(text, other.path) && !isReadable(renamed, other.path)) {
+            throw new Error(`Renaming ${page.name} to ${to} would leave the frontmatter of ${other.path} unreadable, as a ' in a link written between '…' quotes: choose a name without ', or rewrite that field of ${other.path} by hand between "…" quotes, then rename again. Nothing changed.`);
+        }
+        return count === 0 && other !== page ? [] : [{ other, full, text, renamed, count }];
+    });
+    const self = edited.find((one) => one.other === page);
+    const old = { path: join(world.root, page.path), text: self?.text ?? "" };
+    // The old name stays among its aliases, but for a change of case alone.
+    const sameName = comparableText(page.name) === comparableText(to);
+    const own = { path: join(world.root, path), text: sameName ? (self?.renamed ?? "") : withOldName(self?.renamed ?? "", page.path, page.name, to) };
+    const others = edited.filter((one) => one.other !== page);
+    return {
+        path,
+        links: edited.reduce((sum, one) => sum + one.count, 0),
+        pages: others.map((one) => one.other.name),
+        own,
+        others: others.map((one) => ({ path: one.full, text: one.renamed })),
+        old,
+        ...(kept === undefined ? {} : { kept: kept.path }),
+    };
+}
+/**
+ * Writes a planned rename: the page's new file first, then the links, and the old file goes last, so that a rename stopped half way leaves the page whole
+ * and is finished by planning it again. A change of case alone is the same file on Windows and macOS: the links first, then the file anew.
+ */
+export function applyRename(plan) {
+    if (comparableText(plan.own.path) !== comparableText(plan.old.path)) {
+        files().write(plan.own.path, plan.own.text);
+        plan.others.forEach((other) => files().write(other.path, other.text));
+        files().remove(plan.old.path);
+        return;
+    }
+    plan.others.forEach((other) => files().write(other.path, other.text));
+    files().remove(plan.old.path);
+    try {
+        files().write(plan.own.path, plan.own.text);
+    }
+    catch (error) {
+        files().write(plan.old.path, plan.old.text);
+        throw error;
+    }
+}
+/** A text with its links to a page renamed, [[Lupa]], [[Lupa#Morso]] and [[Lupa|la lupa]] alike, in any case; and how many it renamed. */
+export function renamedLinks(text, from, to) {
+    let count = 0;
+    const renamed = text.replace(/\[\[([^\][|#^]+?)(\s*[#^][^\][|]*)?(\|[^\][]*)?\]\]/g, (link, name, section, words) => {
+        if (comparableText(name.trim()) !== comparableText(from)) {
+            return link;
+        }
+        count += 1;
+        return `[[${to}${section ?? ""}${words ?? ""}]]`;
+    });
+    return { renamed, count };
+}
+/** Whether a page's frontmatter can be read. */
+function isReadable(text, path) {
+    try {
+        readFields(splitPageFile(text).frontmatter, path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** A page's text with its old name among its aliases, and its new one out of them; aliases written as one text become a list. */
+function withOldName(text, path, from, to) {
+    const file = splitPageFile(text);
+    const aliases = readFields(file.frontmatter, path).aliases;
+    const kept = textsIn(aliases).filter((alias) => comparableText(alias.trim()) !== comparableText(to));
+    const listed = kept.some((alias) => comparableText(alias.trim()) === comparableText(from));
+    const change = Array.isArray(aliases) && kept.length === aliases.length
+        ? { add: { aliases: listed ? [] : [from] } }
+        : { set: { aliases: listed ? kept : [...kept, from] } };
+    return joinPageFile({ ...file, frontmatter: changeFields(file.frontmatter, change, path) });
+}

package/dist/pages/roads.d.ts

@@ -0,0 +1,11 @@
+/** A road's stops, by the names their links give, and the length in metres of each stretch between two of them (ROA-1). */
+export interface Stops {
+    stops: string[];
+    lengths: number[];
+}
+/** How a road's stops are written, for messages. */
+export declare const stopsHelp = "its stops in order, with the length of each stretch between them, such as [[Guadoscuro]], 8 km, [[Bivio]], 4 km, [[Rocca]]";
+/** A road's stops and the lengths between them (ROA-1), or why the field cannot be read: links and lengths taking turns, a link first and last, at least two, never the same twice in a row. */
+export declare function readStops(value: unknown): Stops | {
+    problem: string;
+};

package/dist/pages/roads.js

@@ -0,0 +1,40 @@
+// Roads (D-256, ROA-1): places with stops, the places they join in order, and the lengths between them.
+import { lengthHelp, readLength } from "../core/length.js";
+import { comparableText } from "../core/text.js";
+import { links } from "./markdown.js";
+/** How a road's stops are written, for messages. */
+export const stopsHelp = "its stops in order, with the length of each stretch between them, such as [[Guadoscuro]], 8 km, [[Bivio]], 4 km, [[Rocca]]";
+/** A road's stops and the lengths between them (ROA-1), or why the field cannot be read: links and lengths taking turns, a link first and last, at least two, never the same twice in a row. */
+export function readStops(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        return { problem: `must be a list of ${stopsHelp}.` };
+    }
+    const stops = [];
+    const lengths = [];
+    for (const [index, item] of value.entries()) {
+        const text = typeof item === "string" ? item.trim() : String(item);
+        // [[Rocca]] written without quotes is, in YAML, a list inside a list.
+        if (Array.isArray(item)) {
+            return { problem: `has a link written without quotes, which YAML reads as a list: write each stop in quotes, such as "[[Rocca]]".` };
+        }
+        if (index % 2 === 0) {
+            const link = /^\[\[[^\]]+\]\]$/.test(text) ? links(text) : [];
+            if (link.length !== 1) {
+                return { problem: `has ${JSON.stringify(item)} where a stop goes: give ${stopsHelp}.` };
+            }
+            stops.push(link[0].page);
+        }
+        else {
+            const length = readLength(text);
+            if (length === undefined) {
+                return { problem: `has ${JSON.stringify(item)} where the length of a stretch goes: write ${lengthHelp}.` };
+            }
+            lengths.push(length);
+        }
+    }
+    if (value.length % 2 === 0 || stops.length < 2) {
+        return { problem: `must start and end with a stop and have at least two: give ${stopsHelp}.` };
+    }
+    const repeated = stops.findIndex((stop, index) => index > 0 && comparableText(stop) === comparableText(stops[index - 1]));
+    return repeated === -1 ? { stops, lengths } : { problem: `has ${stops[repeated]} twice in a row: a stretch joins two different stops.` };
+}

package/dist/pages/standard-fields.d.ts

@@ -0,0 +1,31 @@
+import type { PageType } from "./page-types.ts";
+/** The fields a new page of this type starts with, unless they are given. */
+export declare function newPageFields(type: PageType): Record<string, unknown>;
+/** The fields that list what a page holds: a place's or an item's contents and a character's inventory. */
+export declare const containerFields: string[];
+/** The field where a page of a type lists what it holds (CON-1): contains for places and items, inventory for characters; undefined for the types that hold nothing. */
+export declare function containerFieldOf(type: PageType | undefined): "contains" | "inventory" | undefined;
+/** Whether a page of the type `holder` can hold one of the type `held` (CON-1, D-150, D-156): a place holds places, characters and items; a character carries items; an item holds items and characters. */
+export declare function canHold(holder: PageType | undefined, held: PageType | undefined): boolean;
+/** What a type holds, for messages: "places, characters and items", "items", or "nothing". */
+export declare function heldTypesText(type: PageType | undefined): string;
+/** Whether a name can be a field's: a letter first, then letters, digits, - and _. */
+export declare function isFieldName(name: string): boolean;
+/** The standard fields that are always lists, of links, words or lines, on the pages that have them: read from text as the command line reads them (D-136). */
+export declare const listFieldNames: string[];
+/** Whether a field has a fixed meaning on pages of this type, such as an event's date: such a field is never a counter, but for an event's clock. */
+export declare function isStandardField(type: PageType | undefined, name: string): boolean;
+/** Whether a standard field is a counter, changed with change like any other: an event's clock (EVT-2). */
+export declare function isCounterField(type: PageType | undefined, name: string): boolean;
+/** The values a standard field takes on pages of a type, such as a quest's statuses; undefined when it takes any. */
+export declare function standardValues(type: PageType | undefined, name: string): readonly string[] | undefined;
+/** Checks the standard fields among `names`, the ones a write changed. The other fields are free. */
+export declare function checkStandardFields(type: PageType | undefined, fields: Record<string, unknown>, names: string[]): void;
+/** What is wrong with a standard field, such as "status" must be one of…, or a field named like one in another case, such as Status; undefined when it is right, missing or not standard. */
+export declare function standardFieldProblem(type: PageType | undefined, fields: Record<string, unknown>, name: string): string | undefined;
+/** The standard field that `name` writes in another case or with accents written another way, such as status for Status; undefined otherwise. */
+export declare function misspelledStandardField(type: PageType | undefined, name: string): string | undefined;
+/** Why a field named like a standard one in another case is not read, such as Status; undefined for any other name. */
+export declare function misspelledFieldProblem(type: PageType | undefined, name: string): string | undefined;
+/** Whether a field holds nothing: missing, or empty, as Obsidian writes a property without a value. An empty field counts as missing. */
+export declare function isEmptyField(value: unknown): boolean;

package/dist/pages/standard-fields.js

@@ -0,0 +1,142 @@
+import { readLength } from "../core/length.js";
+import { moods } from "../core/mood.js";
+import { sameName } from "../core/text.js";
+import { mapHelp, readMapField } from "./maps.js";
+import { positionHelp, readPosition } from "./positions.js";
+import { readStops } from "./roads.js";
+const linkPattern = /^\[\[[^\]]+\]\]$/;
+const fieldNamePattern = /^\p{L}[\p{L}\p{M}\p{N}_-]*$/u;
+// A page's picture is a link to a file in an images folder (D-267).
+const commonRules = { tags: "list", aliases: "list", image: "link" };
+const typeRules = {
+    character: { role: ["pc", "companion", "npc"], creature: "link", inventory: "list", equipped: "links", knows: "links", factions: "links", status: ["alive", "dead"], mood: moods },
+    place: { contains: "list", environment: "lines", stops: "stops", position: "position", radius: "length", map: "map", at: "list" },
+    item: { contains: "list" },
+    creature: { creature: "link" },
+    quest: { status: ["planned", "open", "done", "failed"] },
+    event: { date: "text", place: "link", status: ["planned", "happened", "cancelled"], clock: "counter", when: "conditions", by: "linkOrLinks" },
+};
+// What each type holds, in its container field (CON-1, D-150, D-156): a place never goes into an item or a character.
+const heldTypes = { place: ["place", "character", "item"], character: ["item"], item: ["item", "character"] };
+// What a new page of a type holds when the write that creates it leaves the field out.
+const defaultFields = {
+    quest: { status: "planned" },
+    event: { status: "planned" },
+};
+/** The fields a new page of this type starts with, unless they are given. */
+export function newPageFields(type) {
+    return defaultFields[type] ?? {};
+}
+/** The fields that list what a page holds: a place's or an item's contents and a character's inventory. */
+export const containerFields = ["contains", "inventory"];
+/** The field where a page of a type lists what it holds (CON-1): contains for places and items, inventory for characters; undefined for the types that hold nothing. */
+export function containerFieldOf(type) {
+    return type === "character" ? "inventory" : type === "place" || type === "item" ? "contains" : undefined;
+}
+/** Whether a page of the type `holder` can hold one of the type `held` (CON-1, D-150, D-156): a place holds places, characters and items; a character carries items; an item holds items and characters. */
+export function canHold(holder, held) {
+    return holder !== undefined && held !== undefined && (heldTypes[holder] ?? []).includes(held);
+}
+/** What a type holds, for messages: "places, characters and items", "items", or "nothing". */
+export function heldTypesText(type) {
+    const held = type === undefined ? [] : (heldTypes[type] ?? []).map((name) => `${name}s`);
+    return held.length === 0 ? "nothing" : held.length === 1 ? held[0] : `${held.slice(0, -1).join(", ")} and ${held.at(-1)}`;
+}
+/** Whether a name can be a field's: a letter first, then letters, digits, - and _. */
+export function isFieldName(name) {
+    return fieldNamePattern.test(name);
+}
+/** The standard fields that are always lists, of links, words or lines, on the pages that have them: read from text as the command line reads them (D-136). */
+export const listFieldNames = [
+    ...new Set([commonRules, ...Object.values(typeRules)].flatMap((rules) => Object.entries(rules ?? {}).filter(([, rule]) => ["list", "links", "linkOrLinks", "lines", "stops"].includes(rule)).map(([name]) => name))),
+];
+/** Whether a field has a fixed meaning on pages of this type, such as an event's date: such a field is never a counter, but for an event's clock. */
+export function isStandardField(type, name) {
+    return Object.hasOwn(commonRules, name) || (type !== undefined && Object.hasOwn(typeRules[type] ?? {}, name));
+}
+/** Whether a standard field is a counter, changed with change like any other: an event's clock (EVT-2). */
+export function isCounterField(type, name) {
+    const rules = rulesOf(type);
+    return Object.hasOwn(rules, name) && rules[name] === "counter";
+}
+/** The values a standard field takes on pages of a type, such as a quest's statuses; undefined when it takes any. */
+export function standardValues(type, name) {
+    const rule = Object.hasOwn(rulesOf(type), name) ? rulesOf(type)[name] : undefined;
+    return typeof rule === "object" ? rule : undefined;
+}
+/** Checks the standard fields among `names`, the ones a write changed. The other fields are free. */
+export function checkStandardFields(type, fields, names) {
+    for (const name of names) {
+        const problem = standardFieldProblem(type, fields, name);
+        if (problem !== undefined) {
+            throw new Error(problem);
+        }
+    }
+}
+/** What is wrong with a standard field, such as "status" must be one of…, or a field named like one in another case, such as Status; undefined when it is right, missing or not standard. */
+export function standardFieldProblem(type, fields, name) {
+    const rules = rulesOf(type);
+    if (!(name in fields)) {
+        return undefined;
+    }
+    const misspelled = misspelledFieldProblem(type, name);
+    const problem = Object.hasOwn(rules, name) && !isEmptyField(fields[name]) ? problemWith(fields[name], rules[name]) : undefined;
+    return misspelled ?? (problem === undefined ? undefined : `"${name}" ${problem}`);
+}
+/** The standard field that `name` writes in another case or with accents written another way, such as status for Status; undefined otherwise. */
+export function misspelledStandardField(type, name) {
+    const rules = rulesOf(type);
+    return Object.hasOwn(rules, name) ? undefined : sameName(Object.keys(rules), name);
+}
+/** Why a field named like a standard one in another case is not read, such as Status; undefined for any other name. */
+export function misspelledFieldProblem(type, name) {
+    const standard = misspelledStandardField(type, name);
+    return standard === undefined ? undefined : `"${name}" is the standard field ${standard} written another way, so the engine does not read it: write it as ${standard}.`;
+}
+/** Whether a field holds nothing: missing, or empty, as Obsidian writes a property without a value. An empty field counts as missing. */
+export function isEmptyField(value) {
+    return value === undefined || value === null || (typeof value === "string" && value.trim() === "");
+}
+function rulesOf(type) {
+    return { ...commonRules, ...(type === undefined ? {} : typeRules[type]) };
+}
+function problemWith(value, rule) {
+    if (typeof rule !== "string") {
+        return typeof value === "string" && rule.includes(value) ? undefined : `must be one of: ${rule.join(", ")}.`;
+    }
+    switch (rule) {
+        case "text":
+            return typeof value === "string" || typeof value === "number" ? undefined : "must be text.";
+        case "link":
+            return isLink(value) ? undefined : "must be a link, such as [[Page]].";
+        case "list":
+            return Array.isArray(value) && value.every((item) => typeof item === "string" || typeof item === "number") ? undefined : "must be a list of links or text, such as [[A]], [[B]] or [a, b].";
+        case "links":
+            return Array.isArray(value) && value.every(isLink) ? undefined : "must be a list of links, such as [[A]], [[B]].";
+        case "linkOrLinks":
+            return isLink(value) || (Array.isArray(value) && value.every(isLink)) ? undefined : "must be a link, or a list of links, such as [[Varro]].";
+        case "counter":
+            return typeof value === "string" || typeof value === "number" ? undefined : "must be a counter written current/max, such as 1/4.";
+        case "conditions":
+            return typeof value === "string" || (Array.isArray(value) && value.every((item) => typeof item === "string")) ? undefined : "must be a condition or a list of conditions, as text, such as party in [[Ossario]].";
+        case "lines":
+            return Array.isArray(value) && value.every((item) => typeof item === "string" || isOneKeyMap(item)) ? undefined : 'must be a list of lines, such as ["light: dark"].';
+        case "stops": {
+            const stops = readStops(value);
+            return "problem" in stops ? stops.problem : undefined;
+        }
+        case "position":
+            return readPosition(value) !== undefined ? undefined : `must be a point of the map, ${positionHelp}; write gives one from a relation, such as 12 km NE of [[Guadoscuro]].`;
+        case "length":
+            return readLength(value) !== undefined ? undefined : "must be a length in km or m, such as 10 km.";
+        case "map":
+            return readMapField(value) !== undefined ? undefined : `must be ${mapHelp}, such as under [[Guadoscuro]].`;
+    }
+}
+/** A map of one key, as YAML reads a line such as light: dark written without quotes. */
+function isOneKeyMap(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 1;
+}
+function isLink(value) {
+    return typeof value === "string" && linkPattern.test(value);
+}

package/dist/pages/system-pages.d.ts

@@ -0,0 +1,35 @@
+import type { FieldKind } from "../core/field-kind.ts";
+import type { PageType } from "./page-types.ts";
+import type { Page, World } from "./world.ts";
+/**
+ * Why a page of the game system never goes in a knows: anyone may know its rules, and a creature's numbers are the master's, which the player's view never
+ * shows (SYS-6, D-254); what a character learns of a creature goes in a secret of a page of the campaign.
+ */
+export declare function systemKnowsReason(page: Page): string;
+/** The kind the game system declares for a field, by its name in any case (SYS-8); undefined when it declares none. */
+export declare function declaredKind(world: World, field: string): FieldKind | undefined;
+/** Whether the game system declares a field as something never counted: a number, text or a list, such as cr 1/4 or cost 15 gp (SYS-8). */
+export declare function isDeclaredUncounted(world: World, field: string): boolean;
+/** "a creature of the system 5e": what a page of the game system is, for messages. */
+export declare function systemLabel(page: Page): string;
+/** The list where the game system puts a page for every character who keeps the sheet, as equipped for the unarmed strike (DAT-13); undefined for any other page. */
+export declare function alwaysInList(world: World, page: Page): string | undefined;
+/** "Unarmed Strike is an item of the system 5e that it puts in the equipped of every character with a sheet…": why no one writes or equips it (DAT-13). */
+export declare function alwaysInMessage(page: Page, list: string): string;
+/**
+ * Why a page of the game system cannot be written, and what to write instead: a page of the campaign that derives from it (SYS-6, SYS-7); for one the system puts
+ * in a list of every character, that it is there already (DAT-13).
+ */
+export declare function readOnlyMessage(page: Page, fields?: string[], world?: World): string;
+/**
+ * Why a page of the campaign cannot take the name of a page of the game system, which it would hide (SYS-4), with the name to give it instead; `fields` are those the refused
+ * write gave, such as hp=15/15, for the call to make instead.
+ */
+export declare function hidingMessage(page: Page, type: PageType | undefined, fields?: string[]): string;
+/** Why a page of the game system goes into no container (SYS-6), and what to do instead; `holder` is where it was to go. */
+export declare function heldSystemPageMessage(page: Page, holder: {
+    name: string;
+    type?: PageType;
+}, world?: World): string;
+/** A creature of the game system is a kind: how one enters the story instead (SYS-6, SYS-7). */
+export declare function kindMessage(page: Page): string;

package/dist/pages/system-pages.js

@@ -0,0 +1,98 @@
+import { comparableText, withArticle } from "../core/text.js";
+/**
+ * Why a page of the game system never goes in a knows: anyone may know its rules, and a creature's numbers are the master's, which the player's view never
+ * shows (SYS-6, D-254); what a character learns of a creature goes in a secret of a page of the campaign.
+ */
+export function systemKnowsReason(page) {
+    return page.type === "creature"
+        ? "whose numbers are the master's, never shown in the player's view (what a character learns of it goes in a secret of a page of the campaign)"
+        : "which anyone may know";
+}
+/** The kind the game system declares for a field, by its name in any case (SYS-8); undefined when it declares none. */
+export function declaredKind(world, field) {
+    const fields = world.system?.fields;
+    return fields === undefined ? undefined : kindsOf(fields).get(comparableText(field));
+}
+/** The kinds a system declares, by the name as it is compared, the first written winning: built once for each system, as every field read asks (D-194). */
+function kindsOf(fields) {
+    let kinds = kindsByFields.get(fields);
+    if (kinds === undefined) {
+        kinds = new Map();
+        for (const [name, kind] of Object.entries(fields)) {
+            if (!kinds.has(comparableText(name))) {
+                kinds.set(comparableText(name), kind);
+            }
+        }
+        kindsByFields.set(fields, kinds);
+    }
+    return kinds;
+}
+const kindsByFields = new WeakMap();
+/** Whether the game system declares a field as something never counted: a number, text or a list, such as cr 1/4 or cost 15 gp (SYS-8). */
+export function isDeclaredUncounted(world, field) {
+    const kind = declaredKind(world, field);
+    return kind !== undefined && kind !== "counter";
+}
+/** "a creature of the system 5e": what a page of the game system is, for messages. */
+export function systemLabel(page) {
+    return `${withArticle(page.type ?? "page")} of the system ${page.system ?? ""}`;
+}
+/** The list where the game system puts a page for every character who keeps the sheet, as equipped for the unarmed strike (DAT-13); undefined for any other page. */
+export function alwaysInList(world, page) {
+    return page.system === undefined ? undefined : Object.entries(world.system?.alwaysIn ?? {}).find(([, names]) => names.some((name) => comparableText(name) === comparableText(page.name)))?.[0];
+}
+/** "Unarmed Strike is an item of the system 5e that it puts in the equipped of every character with a sheet…": why no one writes or equips it (DAT-13). */
+export function alwaysInMessage(page, list) {
+    return `${page.name} is ${systemLabel(page)} that it puts in the ${list} of every character with a sheet, worked out on each from their own fields: read-only, and never equipped, carried or derived from by hand, which would count it twice.`;
+}
+/**
+ * Why a page of the game system cannot be written, and what to write instead: a page of the campaign that derives from it (SYS-6, SYS-7); for one the system puts
+ * in a list of every character, that it is there already (DAT-13).
+ */
+export function readOnlyMessage(page, fields = [], world) {
+    const list = world === undefined ? undefined : alwaysInList(world, page);
+    if (list !== undefined) {
+        return `${alwaysInMessage(page, list)} Nothing changed.`;
+    }
+    if (page.type === "creature") {
+        const set = [`creature=[[${page.name}]]`, ...fields].join(", ");
+        return `${page.name} is ${systemLabel(page)}: read-only. For a kind of your own, create a creature that derives from it, under a name in the campaign's language: `
+            + `write "<name>", type creature, set ${set}; for one in particular, a character with creature=[[${page.name}]]. Nothing changed.`;
+    }
+    if (page.type === "item") {
+        const set = [`item=[[${page.name}]]`, ...fields].join(", ");
+        return `${page.name} is ${systemLabel(page)}: read-only. For one that someone has, create an item that derives from it, under a name in the campaign's language: `
+            + `write "<name>", type item, set ${set}, then move it to them. Nothing changed.`;
+    }
+    return `${page.name} is ${systemLabel(page)}: read-only. Nothing changed.`;
+}
+/**
+ * Why a page of the campaign cannot take the name of a page of the game system, which it would hide (SYS-4), with the name to give it instead; `fields` are those the refused
+ * write gave, such as hp=15/15, for the call to make instead.
+ */
+export function hidingMessage(page, type, fields = []) {
+    const field = page.type === "creature" && (type === "creature" || type === "character") ? "creature" : page.type === "item" && type === "item" ? "item" : undefined;
+    const set = [`${field ?? ""}=[[${page.name}]]`, ...fields].join(", ");
+    const derived = field === undefined
+        ? ` Give ${type === undefined ? "it" : `this ${type}`} another name.`
+        : ` Give yours a name of its own, with ${field}=[[${page.name}]]: write "<name>", type ${type ?? ""}, set ${set}.`;
+    return `${page.name} is ${systemLabel(page)}: a page of the campaign with that name would hide it.${derived} Nothing changed.`;
+}
+/** Why a page of the game system goes into no container (SYS-6), and what to do instead; `holder` is where it was to go. */
+export function heldSystemPageMessage(page, holder, world) {
+    const always = world === undefined ? undefined : alwaysInList(world, page);
+    if (always !== undefined) {
+        return alwaysInMessage(page, always);
+    }
+    if (page.type === "item") {
+        const list = holder.type === "character" ? "the inventory" : "the contents";
+        return `${page.name} is ${systemLabel(page)}, a kind: no one holds it. To give ${holder.name} one, create it under a name in the campaign's language: `
+            + `write "<name>", type item, set item=[[${page.name}]]; then move, page "<name>", to ${holder.name}. An item that matters little can stay text in ${list}.`;
+    }
+    return page.type === "creature" ? kindMessage(page) : `${page.name} is ${systemLabel(page)}, which is nowhere.`;
+}
+/** A creature of the game system is a kind: how one enters the story instead (SYS-6, SYS-7). */
+export function kindMessage(page) {
+    return `${page.name} is ${systemLabel(page)}, a kind and read-only: one in a fight is a copy, brought in with scene, creatures ${page.name}=1; `
+        + `one with a name of its own is a character with creature=[[${page.name}]].`;
+}