rpg-engine 0.0.0-stage → 0.1.1

package/dist/pages/environment.js

@@ -0,0 +1,118 @@
+// What holds inside a place, for everything it contains (D-119, D-153, ENV-1–ENV-4).
+import { comparableText } from "../core/text.js";
+import { isEmptyField, isFieldName } from "./standard-fields.js";
+import { locate } from "./world.js";
+/** What holds at a page, entry by entry, from the nearest place of its chain that has it, the page itself first when it is a place (ENV-2). */
+export function environmentAt(world, page) {
+    const found = [];
+    for (const place of placesAround(world, page)) {
+        for (const entry of readableEntries(place.fields.environment)) {
+            if (!found.some((other) => sameName(other.entry.name, entry.name))) {
+                found.push({ entry, place });
+            }
+        }
+    }
+    return found;
+}
+/**
+ * The entries a place's environment holds, read line by line, so that nothing else falls with a line that does not read (ENV-1): such a line is left out,
+ * one without a value counts as missing (INH-6), and of a name written twice the last line with a value holds (INH-5). validate reports them.
+ */
+function readableEntries(value) {
+    const items = Array.isArray(value) ? value : isEmptyField(value) ? [] : [value];
+    let entries = [];
+    for (const item of items) {
+        const read = readItem(item);
+        if ("entry" in read) {
+            entries = [...entries.filter((entry) => !sameName(entry.name, read.entry.name)), read.entry];
+        }
+    }
+    return entries;
+}
+/** The places whose environment holds at a page, nearest first: the page itself when it is a place, then the places of its chain (ENV-2). */
+export function placesAround(world, page) {
+    return [page, ...locate(world, page).chain].filter((holder) => holder.type === "place");
+}
+/** The entries a place's environment holds (ENV-1); or why it cannot be read. A line written without quotes, which YAML reads as a map of one key, is the line it was. */
+export function readEnvironment(value) {
+    if (isEmptyField(value)) {
+        return { entries: [] };
+    }
+    if (!Array.isArray(value)) {
+        return { problem: 'environment must be a list of lines, one for each entry, such as ["light: dark"].' };
+    }
+    const entries = [];
+    for (const item of value) {
+        const read = readItem(item);
+        if ("problem" in read) {
+            return read;
+        }
+        if (entries.some((entry) => sameName(entry.name, read.entry.name))) {
+            return { problem: `The environment entry ${read.entry.name} is written twice: keep one.` };
+        }
+        entries.push(read.entry);
+    }
+    return { entries };
+}
+/** An entry as its line is written: light: dark. */
+export function formatEnvironmentEntry(entry) {
+    return `${entry.name}: ${entry.value}`;
+}
+/**
+ * The lines of a place's environment after a write (ENV-4): `remove` takes entries out by name, `add` puts one in, or in place of the one with its name.
+ * `place` names the place in messages.
+ */
+export function changedEnvironment(current, add, remove, place) {
+    const read = readEnvironment(current);
+    if ("problem" in read) {
+        throw new Error(`${read.problem} Set it whole on ${place}, such as set environment=["light: dark"], or unset it.`);
+    }
+    let entries = read.entries;
+    for (const item of remove) {
+        const name = String(item).split(":")[0].trim();
+        if (!entries.some((entry) => sameName(entry.name, name))) {
+            const listed = entries.length === 0 ? "It has none." : `Its entries: ${entries.map((entry) => entry.name).join(", ")}.`;
+            throw new Error(`${place} has no environment entry ${name}. ${listed}`);
+        }
+        entries = entries.filter((entry) => !sameName(entry.name, name));
+    }
+    for (const item of add) {
+        const added = readItem(item);
+        if ("problem" in added) {
+            throw new Error(added.problem);
+        }
+        const index = entries.findIndex((entry) => sameName(entry.name, added.entry.name));
+        entries = index === -1 ? [...entries, added.entry] : entries.map((entry, position) => (position === index ? added.entry : entry));
+    }
+    return entries.map(formatEnvironmentEntry);
+}
+/** The entry an item of the field writes: a line, or the map of one key that YAML makes of a line without quotes. */
+function readItem(item) {
+    const line = asLine(item);
+    if (line === undefined) {
+        return { problem: `${JSON.stringify(item)} is not a line of environment: write it as name: value, in quotes, such as "light: dark".` };
+    }
+    const separator = line.indexOf(":");
+    const name = separator === -1 ? "" : line.slice(0, separator).trim();
+    const value = separator === -1 ? "" : line.slice(separator + 1).trim();
+    if (!isFieldName(name) || value === "") {
+        return { problem: `"${line}" is not an entry of environment: write a name as a field's, a colon and a value, such as light: dark.` };
+    }
+    return { entry: { name, value } };
+}
+/** A line as text; from a map of one key, as YAML reads light: dark or encounters: [[Swamp#Encounters]] written without quotes. */
+function asLine(item) {
+    if (typeof item === "string") {
+        return item;
+    }
+    const entries = item !== null && typeof item === "object" && !Array.isArray(item) ? Object.entries(item) : [];
+    if (entries.length !== 1) {
+        return undefined;
+    }
+    const [name, value] = entries[0];
+    const link = Array.isArray(value) && value.length === 1 && Array.isArray(value[0]) && value[0].length === 1 && typeof value[0][0] === "string" ? `[[${value[0][0]}]]` : undefined;
+    return link !== undefined ? `${name}: ${link}` : value !== null && typeof value !== "object" ? `${name}: ${String(value)}` : undefined;
+}
+function sameName(first, second) {
+    return comparableText(first) === comparableText(second);
+}

package/dist/pages/index.d.ts

@@ -0,0 +1,15 @@
+export { checkWorld, equippedNotes } from "./check.ts";
+export { applyMove, type MovePlan, planLeave, planMove } from "./containers.ts";
+export { changedEnvironment, environmentAt, type EnvironmentEntry, formatEnvironmentEntry, placesAround, readEnvironment } from "./environment.ts";
+export { baseChain, baseFieldOf, baseValue, derivedPages, followersOf, holdsField, type Inherited, inheritedByBase, inheritedFields, introductionFollowersOf, isNeverInherited, keepersOf, newBaseProblem, ownField, ownFieldChange, removedFieldName, sameAsBase, sectionFollowersOf, shownPart, uniquePage, writtenFieldName, } from "./inheritance.ts";
+export { type MapField, mapHelp, readMapField } from "./maps.ts";
+export { everyGoalTicked, goalsIn, introductionText, type Link, links, readSection, secretNames, sectionTitles, type TextMode, textParts, unreadSecretLines, withoutComments } from "./markdown.ts";
+export { changedFields, type FieldChange, formatFields, readFields, readFieldValue, splitPageFile } from "./page-file.ts";
+export { type PageType, pageTypeNames, worldFolderName } from "./page-types.ts";
+export { formatPosition, type Position, positionHelp, readPosition } from "./positions.ts";
+export { applyRename, planRename, type Renamed, renamedLinks, type RenamePlan } from "./rename-page.ts";
+export { readStops, type Stops, stopsHelp } from "./roads.ts";
+export { canHold, containerFieldOf, containerFields, heldTypesText, isCounterField, isEmptyField, isFieldName, isStandardField, listFieldNames, misspelledFieldProblem, misspelledStandardField, newPageFields, standardValues, } from "./standard-fields.ts";
+export { alwaysInList, alwaysInMessage, declaredKind, heldSystemPageMessage, hidingMessage, isDeclaredUncounted, kindMessage, readOnlyMessage, systemKnowsReason, systemLabel } from "./system-pages.ts";
+export { type Backlink, backlinks, concernsPlayer, createWorld, findPage, heldNames, isInParty, isPartyMember, linksIn, loadWorld, locate, namesakes, type Page, pageFileNamed, type PageMatch, pageNamed, pagesWithName, pagesWithNameOrAlias, pageWithPath, parsePageReference, searchPages, searchSystemPages, systemFirstFix, type SystemInfo, systemPageNamed, type SystemPages, textsIn, validHoldersOf, withPage, type World, } from "./world.ts";
+export { checkFieldChange, type PageChange, writePage } from "./write-page.ts";

package/dist/pages/index.js

@@ -0,0 +1,16 @@
+// The pages of the world: one markdown file with a YAML frontmatter for each thing with a name.
+export { checkWorld, equippedNotes } from "./check.js";
+export { applyMove, planLeave, planMove } from "./containers.js";
+export { changedEnvironment, environmentAt, formatEnvironmentEntry, placesAround, readEnvironment } from "./environment.js";
+export { baseChain, baseFieldOf, baseValue, derivedPages, followersOf, holdsField, inheritedByBase, inheritedFields, introductionFollowersOf, isNeverInherited, keepersOf, newBaseProblem, ownField, ownFieldChange, removedFieldName, sameAsBase, sectionFollowersOf, shownPart, uniquePage, writtenFieldName, } from "./inheritance.js";
+export { mapHelp, readMapField } from "./maps.js";
+export { everyGoalTicked, goalsIn, introductionText, links, readSection, secretNames, sectionTitles, textParts, unreadSecretLines, withoutComments } from "./markdown.js";
+export { changedFields, formatFields, readFields, readFieldValue, splitPageFile } from "./page-file.js";
+export { pageTypeNames, worldFolderName } from "./page-types.js";
+export { formatPosition, positionHelp, readPosition } from "./positions.js";
+export { applyRename, planRename, renamedLinks } from "./rename-page.js";
+export { readStops, stopsHelp } from "./roads.js";
+export { canHold, containerFieldOf, containerFields, heldTypesText, isCounterField, isEmptyField, isFieldName, isStandardField, listFieldNames, misspelledFieldProblem, misspelledStandardField, newPageFields, standardValues, } from "./standard-fields.js";
+export { alwaysInList, alwaysInMessage, declaredKind, heldSystemPageMessage, hidingMessage, isDeclaredUncounted, kindMessage, readOnlyMessage, systemKnowsReason, systemLabel } from "./system-pages.js";
+export { backlinks, concernsPlayer, createWorld, findPage, heldNames, isInParty, isPartyMember, linksIn, loadWorld, locate, namesakes, pageFileNamed, pageNamed, pagesWithName, pagesWithNameOrAlias, pageWithPath, parsePageReference, searchPages, searchSystemPages, systemFirstFix, systemPageNamed, textsIn, validHoldersOf, withPage, } from "./world.js";
+export { checkFieldChange, writePage } from "./write-page.js";

package/dist/pages/inheritance.d.ts

@@ -0,0 +1,80 @@
+import type { FieldChange } from "./page-file.ts";
+import type { PageType } from "./page-types.ts";
+import { type Page, type World } from "./world.ts";
+/** A field and its value as a page writes it. */
+export interface FieldValue {
+    name: string;
+    value: unknown;
+}
+/** What a page reads from one of its bases: fields, the introduction when the page has none, and sections and secrets with their text (INH-4, INH-13). */
+export interface Inherited {
+    base: Page;
+    fields: Record<string, unknown>;
+    introduction: string;
+    parts: {
+        name: string;
+        text: string;
+    }[];
+}
+/** The pages a page derives from, nearest first (INH-3): its creature, that creature's own, and so on. */
+export declare function baseChain(world: World, page: Page): Page[];
+/** A page's fields with what it inherits (INH-4–INH-8): what it holds wins, then the nearest base; a name in another case is the same field, an empty value is missing. */
+export declare function inheritedFields(world: World, page: Page): Record<string, unknown>;
+/**
+ * What a page reads from each base, nearest first, as show gives it (INH-13): the fields it does not hold, the introduction of the nearest base that has one
+ * when the page has none, and the sections and secrets it has none of by name. A secret without a name matches no other, so a base's is always shown.
+ */
+export declare function inheritedByBase(world: World, page: Page): Inherited[];
+/** Whether a page writes a field with the very value it would read from its bases, and in no other case: that is no difference, and the page does not keep it (INH-9, D-125). */
+export declare function sameAsBase(world: World, page: Page, field: string): boolean;
+/** The pages deriving from a page that hold a field themselves, with no base between holding it: a change to it there does not reach them, though it would without their value. */
+export declare function keepersOf(world: World, page: Page, field: string): Page[];
+/** The section or secret `name` that a page shows, its own or the nearest base's (INH-13): where it is written, its title there, and whether it is a secret (REV-1). */
+export declare function shownPart(world: World, page: Page, name: string): {
+    holder: Page;
+    title: string;
+    secret: boolean;
+} | undefined;
+/** Whether a field is one that no page ever inherits (INH-8), however it is written. */
+export declare function isNeverInherited(field: string): boolean;
+/** Whether a page holds a field with a value, written in any case (INH-5, INH-6). */
+export declare function holdsField(page: Page, field: string): boolean;
+/** The field as a page itself writes it, empty or not: written exactly so, else in another case; undefined when the page does not write it. */
+export declare function ownField(page: Page, field: string): string | undefined;
+/**
+ * The name under which a write gives a field a value on a page (INH-5): the one the page reads it from; else the one it writes empty; else the one it inherits; else the name given.
+ * A fixed field keeps the name given, so that a write never lands on one written in another case.
+ */
+export declare function writtenFieldName(world: World, page: Page, field: string): string;
+/** The name under which a write removes a field from a page: as written, else in another case (INH-5); a fixed field only as written. */
+export declare function removedFieldName(page: Page, field: string): string;
+/** A field change as a page takes it (INH-5, INH-7): each field under the name the page gives it, and a list it only inherits handed to it before items are added or removed. */
+export declare function ownFieldChange(world: World, page: Page, change: FieldChange): FieldChange;
+/** What a page would read for a field without its own value: the nearest base that holds it, with the field as that base writes it. */
+export declare function baseValue(world: World, page: Page, field: string): (FieldValue & {
+    base: Page;
+}) | undefined;
+/** The pages that derive from a page, directly or through others. */
+export declare function derivedPages(world: World, page: Page): Page[];
+/** The pages that read a field from a page, or would once it holds it: those deriving from it that hold the field neither themselves nor on a base between them and it (INH-10). */
+export declare function followersOf(world: World, page: Page, field: string): Page[];
+/** The pages that show a section or secret of a page, or would once it has one by that name: those deriving from it that have none, themselves or on a base between (INH-13). */
+export declare function sectionFollowersOf(world: World, page: Page, name: string): Page[];
+/** The pages that show the introduction of a page, or would once it has one: those deriving from it with none of their own, nor on a base between (INH-13). */
+export declare function introductionFollowersOf(world: World, page: Page): Page[];
+/**
+ * The page with this name, when exactly one page of the campaign has it, or else the game system's (SYS-3); undefined when none has it, or two of the campaign do (INH-3).
+ */
+export declare function uniquePage(world: World, name: string): Page | undefined;
+/** The field in which a page of this type names what it derives from (INH-1): creature for characters and creatures, item for items; undefined for the other types. */
+export declare function baseFieldOf(type: PageType | undefined): "creature" | "item" | undefined;
+/** Why a page's base cannot be followed (INH-15): it is not of the type its field names, or the chain comes back to the page. Undefined when it can. */
+export declare function baseProblem(world: World, page: Page): string | undefined;
+/**
+ * Why a page of this type and name cannot derive from the page `link` points to (INH-2, INH-3): it is not of the type the field names, it is the page itself, or the chain would come back.
+ * Undefined when it can, or when that page does not exist yet.
+ */
+export declare function newBaseProblem(world: World, page: {
+    name: string;
+    type?: PageType;
+}, link: string): string | undefined;

package/dist/pages/inheritance.js

@@ -0,0 +1,260 @@
+import { comparableText, sameName, withArticle } from "../core/text.js";
+import { introductionText, secretNames, sectionTitles, textParts } from "./markdown.js";
+import { isEmptyField, isStandardField, misspelledStandardField } from "./standard-fields.js";
+import { alwaysInList, alwaysInMessage } from "./system-pages.js";
+import { linksIn, pagesWithName, systemPageNamed } from "./world.js";
+// The field in which a page of a type names what it derives from, named after the type of its base: for a character or a creature, the creature it is a kind of;
+// for an item, the item (INH-1, D-164). On other types a field with that name means something else, such as the wolf of a trophy, and passes nothing on.
+const baseFields = { character: "creature", creature: "creature", item: "item" };
+// INH-8: never inherited, a closed list of the core: who a page is, what it holds or knows, what holds it for a while, and how it feels (MOOD-3). Fields a system
+// declares are inherited.
+const neverInherited = new Set(["role", "status", "creature", "item", "inventory", "equipped", "knows", "factions", "contains", "date", "place", "tags", "aliases", "effects", "mood"]);
+/** The pages a page derives from, nearest first (INH-3): its creature, that creature's own, and so on. */
+export function baseChain(world, page) {
+    const chain = [];
+    for (let base = nextBase(world, page); base !== undefined && base !== page && !chain.includes(base); base = nextBase(world, base)) {
+        chain.push(base);
+    }
+    return chain;
+}
+/** A page's fields with what it inherits (INH-4–INH-8): what it holds wins, then the nearest base; a name in another case is the same field, an empty value is missing. */
+export function inheritedFields(world, page) {
+    const bases = baseChain(world, page).reverse().map((base) => Object.entries(base.fields).filter(([field]) => !isNeverInherited(field)));
+    // From the farthest base to the page: a nearer value takes the place of a farther one, with its name; fields keep the order in which they first appear.
+    const fields = new Map();
+    for (const layer of [...bases, Object.entries(page.fields)]) {
+        for (const [field, value] of layer.filter(([, candidate]) => !isEmptyField(candidate))) {
+            fields.set(comparableText(field), [field, value]);
+        }
+    }
+    return Object.fromEntries(fields.values());
+}
+/**
+ * What a page reads from each base, nearest first, as show gives it (INH-13): the fields it does not hold, the introduction of the nearest base that has one
+ * when the page has none, and the sections and secrets it has none of by name. A secret without a name matches no other, so a base's is always shown.
+ */
+export function inheritedByBase(world, page) {
+    const chain = baseChain(world, page);
+    const fields = Object.entries(inheritedFields(world, page)).filter(([field]) => !holdsField(page, field));
+    const shown = new Set(textParts(page.body).map((part) => comparableText(part.name)));
+    const introducer = introductionText(page.body) === "" ? chain.find((base) => introductionText(base.body) !== "") : undefined;
+    return chain.flatMap((base) => {
+        const all = textParts(base.body);
+        const kept = new Set(all.filter((part) => part.name === "" || !shown.has(comparableText(part.name))));
+        const parts = all.filter((part, index) => kept.has(part) && !emptyHeading(all, index, kept));
+        kept.forEach((part) => shown.add(comparableText(part.name)));
+        const own = Object.fromEntries(fields.filter(([field]) => baseValue(world, page, field)?.base === base));
+        const introduction = base === introducer ? introductionText(base.body) : "";
+        return Object.keys(own).length > 0 || parts.length > 0 || introduction !== "" ? [{ base, fields: own, introduction, parts }] : [];
+    });
+}
+/**
+ * Whether the part at `index` is a heading with no text of its own whose subsections are none of them `kept`, as when the page writes them all itself: it has nothing
+ * left to show (INH-13, D-169), such as the Actions of a creature whose one action the page rewrote.
+ */
+function emptyHeading(parts, index, kept) {
+    const level = headingLevel(parts[index].text);
+    if (level === undefined || parts[index].text.split("\n").slice(1).some((line) => line.trim() !== "")) {
+        return false;
+    }
+    for (const next of parts.slice(index + 1)) {
+        // A secret has no level: it belongs to the section it is in.
+        if ((headingLevel(next.text) ?? Number.POSITIVE_INFINITY) <= level) {
+            break;
+        }
+        if (kept.has(next)) {
+            return false;
+        }
+    }
+    return true;
+}
+/** The level of the heading a part starts with, 2 for "## Actions"; undefined for a secret. */
+function headingLevel(text) {
+    return /^(#{1,6})[ \t]/.exec(text)?.[1].length;
+}
+/** Whether a page writes a field with the very value it would read from its bases, and in no other case: that is no difference, and the page does not keep it (INH-9, D-125). */
+export function sameAsBase(world, page, field) {
+    const base = baseValue(world, page, field);
+    const held = Object.keys(page.fields).filter((name) => comparableText(name) === comparableText(field) && !isEmptyField(page.fields[name]));
+    return base !== undefined && held.length === 1 && JSON.stringify(page.fields[field]) === JSON.stringify(base.value);
+}
+/** The pages deriving from a page that hold a field themselves, with no base between holding it: a change to it there does not reach them, though it would without their value. */
+export function keepersOf(world, page, field) {
+    if (isNeverInherited(field)) {
+        return [];
+    }
+    return derivedPages(world, page).filter((derived) => {
+        const chain = baseChain(world, derived);
+        return holdsField(derived, field) && !chain.slice(0, chain.indexOf(page)).some((between) => holdsField(between, field));
+    });
+}
+/** The section or secret `name` that a page shows, its own or the nearest base's (INH-13): where it is written, its title there, and whether it is a secret (REV-1). */
+export function shownPart(world, page, name) {
+    const wanted = comparableText(name.trim());
+    for (const holder of [page, ...baseChain(world, page)]) {
+        const secret = secretNames(holder.body).find((title) => title !== "" && comparableText(title) === wanted);
+        const section = sectionTitles(holder.body).find((title) => comparableText(title) === wanted);
+        if (secret !== undefined || section !== undefined) {
+            return { holder, title: secret ?? section ?? name, secret: secret !== undefined };
+        }
+    }
+    return undefined;
+}
+/** Whether a field is one that no page ever inherits (INH-8), however it is written. */
+export function isNeverInherited(field) {
+    return neverInherited.has(comparableText(field));
+}
+/** Whether a page holds a field with a value, written in any case (INH-5, INH-6). */
+export function holdsField(page, field) {
+    return heldName(page, field) !== undefined;
+}
+/** The field as a page itself writes it, empty or not: written exactly so, else in another case; undefined when the page does not write it. */
+export function ownField(page, field) {
+    if (Object.hasOwn(page.fields, field)) {
+        return field;
+    }
+    return heldName(page, field) ?? sameName(Object.keys(page.fields), field);
+}
+/**
+ * The name under which a write gives a field a value on a page (INH-5): the one the page reads it from; else the one it writes empty; else the one it inherits; else the name given.
+ * A fixed field keeps the name given, so that a write never lands on one written in another case.
+ */
+export function writtenFieldName(world, page, field) {
+    if (isFixedName(page, field)) {
+        return field;
+    }
+    return heldName(page, field) ?? ownField(page, field) ?? baseValue(world, page, field)?.name ?? field;
+}
+/** The name under which a write removes a field from a page: as written, else in another case (INH-5); a fixed field only as written. */
+export function removedFieldName(page, field) {
+    return isFixedName(page, field) ? field : (ownField(page, field) ?? field);
+}
+/** A field change as a page takes it (INH-5, INH-7): each field under the name the page gives it, and a list it only inherits handed to it before items are added or removed. */
+export function ownFieldChange(world, page, change) {
+    const renamed = (values) => {
+        return values === undefined ? undefined : Object.fromEntries(Object.entries(values).map(([field, value]) => [writtenFieldName(world, page, field), value]));
+    };
+    const set = renamed(change.set);
+    const add = renamed(change.add);
+    const remove = renamed(change.remove);
+    const lists = [...new Set([...Object.keys(add ?? {}), ...Object.keys(remove ?? {})])].filter((field) => !Object.hasOwn(set ?? {}, field) && !holdsField(page, field));
+    const inherited = lists.flatMap((field) => {
+        const base = baseValue(world, page, field);
+        return base === undefined ? [] : [[field, structuredClone(base.value)]];
+    });
+    return { set: { ...Object.fromEntries(inherited), ...set }, unset: change.unset?.map((field) => removedFieldName(page, field)), add, remove };
+}
+/** What a page would read for a field without its own value: the nearest base that holds it, with the field as that base writes it. */
+export function baseValue(world, page, field) {
+    if (isNeverInherited(field)) {
+        return undefined;
+    }
+    for (const base of baseChain(world, page)) {
+        const name = heldName(base, field);
+        if (name !== undefined) {
+            return { name, value: base.fields[name], base };
+        }
+    }
+    return undefined;
+}
+/** The pages that derive from a page, directly or through others. */
+export function derivedPages(world, page) {
+    return world.pages.filter((candidate) => baseChain(world, candidate).includes(page));
+}
+/** The pages that read a field from a page, or would once it holds it: those deriving from it that hold the field neither themselves nor on a base between them and it (INH-10). */
+export function followersOf(world, page, field) {
+    return isNeverInherited(field) ? [] : followers(world, page, (candidate) => holdsField(candidate, field));
+}
+/** The pages that show a section or secret of a page, or would once it has one by that name: those deriving from it that have none, themselves or on a base between (INH-13). */
+export function sectionFollowersOf(world, page, name) {
+    return followers(world, page, (candidate) => textParts(candidate.body).some((part) => comparableText(part.name) === comparableText(name)));
+}
+/** The pages that show the introduction of a page, or would once it has one: those deriving from it with none of their own, nor on a base between (INH-13). */
+export function introductionFollowersOf(world, page) {
+    return followers(world, page, (candidate) => introductionText(candidate.body) !== "");
+}
+/**
+ * The page with this name, when exactly one page of the campaign has it, or else the game system's (SYS-3); undefined when none has it, or two of the campaign do (INH-3).
+ */
+export function uniquePage(world, name) {
+    const found = pagesWithName(world, name);
+    return found.length === 0 ? systemPageNamed(world, name) : found.length === 1 ? found[0] : undefined;
+}
+/** The field in which a page of this type names what it derives from (INH-1): creature for characters and creatures, item for items; undefined for the other types. */
+export function baseFieldOf(type) {
+    return type === undefined ? undefined : baseFields[type];
+}
+/** Why a page's base cannot be followed (INH-15): it is not of the type its field names, or the chain comes back to the page. Undefined when it can. */
+export function baseProblem(world, page) {
+    const field = baseFieldOf(page.type);
+    const [name] = field === undefined ? [] : linksIn(page.fields[field]);
+    const linked = name === undefined ? undefined : uniquePage(world, name);
+    if (field === undefined || linked === undefined) {
+        return undefined;
+    }
+    if (linked.type !== field) {
+        return `${page.name} derives from ${linked.name}, which is ${withArticle(linked.type ?? "free page")}: ${field} must link to ${withArticle(field)}.`;
+    }
+    const seen = [page];
+    // Only a chain that comes back to this page is its own problem: one that loops further on is reported on the pages of the loop.
+    for (let current = linked; current !== undefined && !seen.includes(current); current = nextBase(world, current)) {
+        seen.push(current);
+    }
+    return nextBase(world, seen[seen.length - 1]) === page ? `${page.name} derives from itself: ${[...seen, page].map((link) => link.name).join(" › ")}.` : undefined;
+}
+/**
+ * Why a page of this type and name cannot derive from the page `link` points to (INH-2, INH-3): it is not of the type the field names, it is the page itself, or the chain would come back.
+ * Undefined when it can, or when that page does not exist yet.
+ */
+export function newBaseProblem(world, page, link) {
+    const field = baseFieldOf(page.type);
+    const [name] = field === undefined ? [] : linksIn(link);
+    if (field === undefined || name === undefined) {
+        return undefined;
+    }
+    if (comparableText(name) === comparableText(page.name)) {
+        return `${page.name} cannot derive from itself: ${field} must link to another ${field}.`;
+    }
+    const target = uniquePage(world, name);
+    if (target === undefined) {
+        return undefined;
+    }
+    if (target.type !== field) {
+        return `${field} must link to ${withArticle(field)}, and ${target.name} is ${withArticle(target.type ?? "free page")}.`;
+    }
+    // What the system puts in every sheet's list, as the unarmed strike, would count twice through an item that derives from it (DAT-13).
+    const always = alwaysInList(world, target);
+    if (always !== undefined) {
+        return alwaysInMessage(target, always);
+    }
+    // The chain, and the page its last base links to, where the chain stops: it may be this one, a page of the same type about to be created.
+    const chain = [target, ...baseChain(world, target)];
+    const last = chain[chain.length - 1];
+    const [next] = linksIn(last.fields[baseFieldOf(last.type) ?? field]);
+    const names = [...chain.map((linked) => linked.name), ...(page.type === field && next !== undefined ? [next] : [])];
+    const back = names.findIndex((linked) => comparableText(linked) === comparableText(page.name));
+    return back === -1 ? undefined : `${page.name} cannot derive from ${target.name}: the chain would come back to it (${[page.name, ...names.slice(0, back), page.name].join(" › ")}).`;
+}
+/** The pages deriving from a page for which nothing nearer holds what `holds` looks for: neither they nor a base between them and the page. */
+function followers(world, page, holds) {
+    return derivedPages(world, page).filter((derived) => {
+        const chain = baseChain(world, derived);
+        return ![derived, ...chain.slice(0, chain.indexOf(page))].some(holds);
+    });
+}
+/** The page a page derives from (INH-2): the page of the type its base field names that the field links to, when exactly one page has that name. */
+function nextBase(world, page) {
+    const field = baseFieldOf(page.type);
+    const [name] = field === undefined ? [] : linksIn(page.fields[field]);
+    // A page of the game system derives from one of its own, never from the campaign's (SYS-2, D-201): Hill Dwarf from Dwarf.
+    const base = name === undefined ? undefined : page.system !== undefined ? systemPageNamed(world, name) : uniquePage(world, name);
+    return base !== undefined && base.type === field ? base : undefined;
+}
+/** Whether a name is a fixed field of the page's type, or one written in another case, which is another field. */
+function isFixedName(page, field) {
+    return isStandardField(page.type, field) || misspelledStandardField(page.type, field) !== undefined;
+}
+/** The name under which a page holds a field with a value, as reading takes it: the last one written in any case; undefined when it holds none. */
+function heldName(page, field) {
+    return Object.keys(page.fields).findLast((name) => comparableText(name) === comparableText(field) && !isEmptyField(page.fields[name]));
+}

package/dist/pages/maps.d.ts

@@ -0,0 +1,11 @@
+/** How a place holds its map: with coordinates of its own, or with those of another place's map, under it or as its mirror. */
+export type MapField = {
+    how: "own";
+} | {
+    how: "under" | "mirror";
+    of: string;
+};
+/** How the map field is written, for messages. */
+export declare const mapHelp = "own, for coordinates of its own, or under [[Place]] or mirror of [[Place]], for those of that place's map";
+/** A place's map field as written (POS-8): own, under [[Place]] or mirror of [[Place]]; undefined for anything else. */
+export declare function readMapField(value: unknown): MapField | undefined;

package/dist/pages/maps.js

@@ -0,0 +1,14 @@
+// Maps (D-320, POS-8): a place that holds a map of its own, with coordinates of its own, or aligned with another place's map, under it or as its mirror.
+/** How the map field is written, for messages. */
+export const mapHelp = "own, for coordinates of its own, or under [[Place]] or mirror of [[Place]], for those of that place's map";
+/** A place's map field as written (POS-8): own, under [[Place]] or mirror of [[Place]]; undefined for anything else. */
+export function readMapField(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    if (/^\s*own\s*$/i.test(value)) {
+        return { how: "own" };
+    }
+    const match = /^\s*(under|mirror of)\s+\[\[([^\]|#]+)(?:[|#][^\]]*)?\]\]\s*$/i.exec(value);
+    return match === null ? undefined : { how: match[1].toLowerCase() === "under" ? "under" : "mirror", of: match[2].trim() };
+}

package/dist/pages/markdown.d.ts

@@ -0,0 +1,59 @@
+/** Where a link points: a page, and a section or secret of it. */
+export interface Link {
+    page: string;
+    section?: string;
+}
+/** The titles of the sections in a markdown text. Read once for each text: rules looks through every page's (RUL-6). */
+export declare function sectionTitles(text: string): string[];
+/** The names of the secret blocks, written `> [!secret] Name`, in a markdown text. */
+export declare function secretNames(text: string): string[];
+/** Names that a text gives to more than one section or secret, ignoring case; each is listed once, as first written. */
+export declare function repeatedNames(text: string): string[];
+/** The sections and secrets of a text, in order, each with its own text: a section's heading and lines up to the next heading, without the secrets in them, which are parts of their own. */
+export declare function textParts(text: string): {
+    name: string;
+    text: string;
+}[];
+/** The introduction of a text, before the first heading, without its secrets. */
+export declare function introductionText(text: string): string;
+/** The own text of a section, without its heading, subsections and secrets, or of a secret, without its mark and quotes; undefined when the text has no part with that name. */
+export declare function partContent(text: string, name: string): {
+    secret: boolean;
+    content: string;
+} | undefined;
+/** A section with its subsections, down to the next heading of the same or a higher level, or a secret block. Names ignore case. */
+export declare function readSection(text: string, title: string): string | undefined;
+/** How text is written: in place of the old text, added at its end, or, empty, removing a section or secret. */
+export type TextMode = "replace" | "append" | "remove";
+/**
+ * Writes the introduction (the text before the first heading), a section's own text (its subsections stay) or a secret block.
+ * Secret blocks inside a rewritten text stay, after the new text. A missing section is added at the end: at the page's top heading level, or as a secret block.
+ */
+export declare function writeText(text: string, newText: string, options: {
+    section?: string;
+    mode: TextMode;
+    secret?: boolean;
+}): string;
+/** The pages a text links to, as in [[Page]], [[Page#Section]], [[Page|label]] or [[folder/Page.md]]. Links in code and in %% comments %% do not count. */
+export declare function linkedPages(text: string): string[];
+/**
+ * The links of a text, with the section or secret they point to, as in [[Page#Section]]. Links in code and in %% comments %%, and attachments as ![[map.png]],
+ * do not count. Read once for each text.
+ */
+export declare function links(text: string): Link[];
+/** Removes the blank lines at the start and the white space at the end. */
+export declare function trimBlankLines(text: string): string;
+/** A text without its comments, as Obsidian shows it in reading view: what lies between %% marks, also across lines, and HTML comments; code stays as it is (LNK-2). */
+export declare function withoutComments(text: string): string;
+/** The lines, counted from 1, that mark a secret the engine does not read as one, as a callout four spaces in: written for a secret, read as public text. */
+export declare function unreadSecretLines(text: string): number[];
+/** The goals a text lists as checkboxes, outside code blocks, each with whether it is ticked; and the text without them, for a quest's card (VIEW-8). */
+export declare function goalsIn(text: string): {
+    goals: {
+        text: string;
+        done: boolean;
+    }[];
+    rest: string;
+};
+/** Whether a text lists goals as checkboxes, outside code blocks, and every one is ticked. */
+export declare function everyGoalTicked(text: string): boolean;