@heroiclands/package-build 23.0.0 → 23.1.1

package/engine/data-keys.mjs

@@ -0,0 +1,347 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * **The inner keys of a `data:` field**, and the one check that holds every
+ * field's value to them.
+ *
+ * `data:` is closed at its own level by the frontmatter lint. A field whose value
+ * holds maps is closed the same way one level down and at every level below: its
+ * declaration states what the value holds, and a key the declaration does not
+ * name is a finding at that key's own `file:line:column`.
+ *
+ * A declaration states its contents with the same descriptor vocabulary a
+ * field uses — `name`, `kind`, `shape`, `describe` — plus three properties
+ * saying where the maps are:
+ *
+ * - **`fields`** — the value is a map with these keys and no others. Each is an
+ *   {@link InnerKeySpec}, which may itself carry `fields`, `entries` or
+ *   `values`.
+ * - **`entries`** — the value is a list, and this describes one entry. A list
+ *   of Addresses states `entryKind` instead.
+ * - **`values`** — the value is a map whose keys are data (an Address, a
+ *   Shortcode, a pack, a name), and this describes the value under each key.
+ *   The keys themselves are checked as the field's `keyKind` says.
+ *
+ * Dotted field names (`appearance.eye_color`) declare a container's keys by
+ * their segments, and the container is closed to them just the same.
+ *
+ * **What the check owns is shape**: an undeclared key, a required key that is
+ * absent, and a present value of the wrong kind. What a value *means* — whether
+ * an Address resolves, a bearing is one of eight, a ladder repeats a level —
+ * stays with the field's own `check`, which skips a value of the wrong shape
+ * because this check has already reported it.
+ *
+ * @module
+ */
+
+import { isAddressTuple } from "./address.mjs";
+import { AddressEntries, AddressLink } from "./address-values.mjs";
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+import { nearest } from "./near-miss.mjs";
+
+/**
+ * One key inside a field's value.
+ *
+ * @typedef {object} InnerKeySpec
+ * @property {string} name - The key as an author writes it.
+ * @property {string} [kind] - Its value's shape: `string`, `date`, `number`,
+ *   `integer`, `boolean`, `address`, `list`, `map`, `scalar-or-map`,
+ *   `list-or-map` or `string-or-list` — see {@link fitsKind}. Absent, the check
+ *   makes no claim about the value.
+ * @property {readonly string[]} [allowed] - The closed set a present value is
+ *   one of, where the key takes a fixed word.
+ * @property {boolean} [verbatim] - The value is a symbol, such as a unit, and
+ *   every surface shows it exactly as written, never recased.
+ * @property {string} shape - The shape in words, for a finding and the reference.
+ * @property {boolean} [required] - The key must be stated, with a value.
+ * @property {boolean} [nullable] - An explicit `null` states the key, for a
+ *   required key whose null has a meaning of its own.
+ * @property {string} [label] - The infobox row label, where humanising the key
+ *   reads wrongly.
+ * @property {string} describe - One line, for the author-facing reference.
+ * @property {readonly InnerKeySpec[]} [fields] - Its own keys, where it is a map.
+ * @property {object} [entries] - One entry, where it is a list of maps.
+ * @property {object} [values] - One value, where it is a map keyed by data.
+ */
+
+/** Whether a value is a plain map rather than a list, an Address or a scalar. */
+export function isPlainMap(value) {
+    return (
+        value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        !isAddressTuple(value) &&
+        !(value instanceof AddressLink) &&
+        !(value instanceof AddressEntries)
+    );
+}
+
+/** Whether a value is one value rather than a container of them. */
+function isScalar(value) {
+    return (
+        typeof value !== "object" ||
+        value === null ||
+        isAddressTuple(value) ||
+        value instanceof AddressLink
+    );
+}
+
+/**
+ * Whether a present value has a declared kind's shape.
+ *
+ * Shape alone: whether an Address resolves, or a word is in a closed set, is the
+ * field's own check's question. Lenient where YAML is ambiguous — `"12"` is a
+ * number, an emptied map arrives as `[]`, and a `date` may be the bare number
+ * YAML reads `720.1` as — and strict where it is not: a `string` is text, so a
+ * title or a description written as `5` is a finding rather than a value
+ * nothing reads as text. An `address` is one value or a parsed Address; what it
+ * names is the reference check's.
+ *
+ * @param {unknown} value - The authored value, not `undefined` or `null`.
+ * @param {string|undefined} kind - The declared kind.
+ * @returns {boolean} Whether it fits.
+ */
+export function fitsKind(value, kind) {
+    switch (kind) {
+        case "string":
+            return typeof value === "string";
+        case "date":
+            return (
+                typeof value === "string" || (typeof value === "number" && Number.isFinite(value))
+            );
+        case "address":
+        case "shortcode":
+            return isScalar(value) && typeof value !== "boolean";
+        case "number":
+            return typeof value === "number" ?
+                    Number.isFinite(value)
+                :   typeof value === "string" &&
+                        value.trim() !== "" &&
+                        Number.isFinite(Number(value));
+        case "integer":
+            return fitsKind(value, "number") && Number.isInteger(Number(value));
+        case "boolean":
+            return typeof value === "boolean";
+        case "list":
+            return Array.isArray(value);
+        case "map":
+            return (
+                isPlainMap(value) ||
+                value instanceof AddressEntries ||
+                (Array.isArray(value) && value.length === 0)
+            );
+        case "scalar-or-map":
+            return isScalar(value) || fitsKind(value, "map");
+        case "list-or-map":
+            return Array.isArray(value) || fitsKind(value, "map");
+        case "string-or-list":
+            return isScalar(value) || Array.isArray(value);
+        default:
+            return true;
+    }
+}
+
+/**
+ * The entries of a map value, whatever form it reached the lint in.
+ *
+ * A map keyed by Address arrives as an {@link AddressEntries} once the note
+ * boundary has typed its keys; `sourceKey` is the text the file holds, so a
+ * finding locates on what the author wrote.
+ *
+ * @param {unknown} value - A map value.
+ * @returns {Array<[string, unknown]>} Its authored keys and values.
+ */
+export function mapEntriesOf(value) {
+    if (value instanceof AddressEntries)
+        return value.entries.map((entry) => [entry.sourceKey, entry.value]);
+    if (isPlainMap(value)) return Object.entries(value);
+    return [];
+}
+
+/**
+ * A field declaration as the tree its dotted names describe.
+ *
+ * `appearance.eye_color` and `appearance.hair_color` are two keys of one
+ * container, `appearance`, which is itself a map closed to them. Grouping them
+ * here is what lets one walk close the container and every field inside it.
+ *
+ * @param {readonly object[]} fields - The type's `data:` declaration.
+ * @returns {object[]} One spec per top-level key, a dotted group as a `map`
+ *   whose `fields` are its members, with `grouped: true`.
+ */
+export function topLevelSpecs(fields) {
+    const out = [];
+    const groups = new Map();
+    for (const field of fields) {
+        const [head, ...rest] = field.name.split(".");
+        if (!rest.length) {
+            out.push(field);
+            continue;
+        }
+        let group = groups.get(head);
+        if (!group) {
+            group = { name: head, kind: "map", shape: "a map", grouped: true, members: [] };
+            groups.set(head, group);
+            out.push(group);
+        }
+        group.members.push({ ...field, name: rest.join(".") });
+    }
+    for (const group of groups.values()) {
+        group.fields = topLevelSpecs(group.members);
+        delete group.members;
+    }
+    return out;
+}
+
+/**
+ * A path as a reader writes it: `data.routes[0].terrain`.
+ *
+ * @param {ReadonlyArray<string|number>} path - The path from the top of the frontmatter.
+ * @returns {string} The label.
+ */
+export function pathLabel(path) {
+    let out = "";
+    for (const segment of path) {
+        if (typeof segment === "number") out += `[${segment}]`;
+        else out += out ? `.${segment}` : segment;
+    }
+    return out;
+}
+
+/** Whether a required key's value counts as stated. */
+function stated(value, spec) {
+    if (value === undefined) return false;
+    if (value === null) return Boolean(spec.nullable);
+    if (typeof value === "string") return value.trim() !== "";
+    return true;
+}
+
+/**
+ * Check every declared field's value against its stated inner keys.
+ *
+ * Run by the frontmatter lint after the container check has refused undeclared
+ * top-level keys and checked each top-level field's own kind, so neither is
+ * repeated here.
+ *
+ * @param {object} note - The note: `file`, `raw` and parsed `fm`.
+ * @param {readonly object[]} fields - The type's `data:` declaration, shared
+ *   fields included.
+ * @returns {object[]} Findings, `file:line:column` located on the key at fault.
+ */
+export function checkDataKeys(note, fields) {
+    const data = note.fm?.data;
+    if (!isPlainMap(data)) return [];
+    const findings = [];
+    const raw = note.raw ?? "";
+    const finding = (path, message, key = false) => ({
+        file: note.file,
+        ...positionOfFrontmatterPath(raw, path, { key }),
+        severity: "error",
+        message,
+    });
+
+    /**
+     * Walk one value against its declaration.
+     *
+     * @param {object} spec - The declaration.
+     * @param {unknown} value - The value, present and non-null.
+     * @param {Array<string|number>} path - Where it sits.
+     */
+    const walk = (spec, value, path) => {
+        if (spec.fields && isPlainMap(value)) {
+            closeMap(spec.fields, value, path);
+            return;
+        }
+        if (Array.isArray(value)) {
+            const entry = spec.entries;
+            if (!entry) return;
+            value.forEach((item, i) => visit(entry, item, [...path, i]));
+            return;
+        }
+        if (spec.values) {
+            for (const [key, item] of mapEntriesOf(value)) visit(spec.values, item, [...path, key]);
+        }
+    };
+
+    /** Check one present value's kind, then walk it. */
+    const visit = (spec, value, path) => {
+        if (value === undefined || value === null) return;
+        if (!fitsKind(value, spec.kind)) {
+            findings.push(
+                finding(
+                    path,
+                    `\`${pathLabel(path)}\` should be ${spec.shape ?? spec.kind}, but reads ` +
+                        JSON.stringify(value),
+                ),
+            );
+            return;
+        }
+        if (spec.allowed && !spec.allowed.includes(value)) {
+            const guess = typeof value === "string" ? nearest(value, spec.allowed) : undefined;
+            findings.push(
+                finding(
+                    path,
+                    `\`${pathLabel(path)}\` should be ${spec.allowed.map((word) => `\`${word}\``).join(" or ")}, ` +
+                        `but reads ${JSON.stringify(value)}` +
+                        (guess ? `. Did you mean "${guess}"?` : ""),
+                ),
+            );
+            return;
+        }
+        walk(spec, value, path);
+    };
+
+    /** Close one map to its declared keys, and walk each that is present. */
+    const closeMap = (inner, value, path) => {
+        const names = inner.map((spec) => spec.name);
+        for (const key of Object.keys(value)) {
+            if (names.includes(key)) continue;
+            const guess = nearest(key, names);
+            findings.push(
+                finding(
+                    [...path, key],
+                    `"${key}" is not a key of \`${pathLabel(path)}\`; it takes only ` +
+                        names.map((name) => `\`${name}\``).join(", ") +
+                        (guess ? `. Did you mean "${guess}"?` : ""),
+                    true,
+                ),
+            );
+        }
+        for (const spec of inner) {
+            const item = value[spec.name];
+            if (spec.required && !stated(item, spec)) {
+                findings.push(
+                    finding(
+                        path,
+                        `\`${pathLabel(path)}\` must state \`${spec.name}\` — ${spec.shape}`,
+                        typeof path.at(-1) !== "number",
+                    ),
+                );
+                continue;
+            }
+            visit(spec, item, [...path, spec.name]);
+        }
+    };
+
+    for (const spec of topLevelSpecs(fields)) {
+        const value = data[spec.name];
+        if (value === undefined || value === null) continue;
+        const path = ["data", spec.name];
+        // A dotted group's own shape is checked here: the container check
+        // reads its members' leaves and has nothing to say about the group.
+        if (spec.grouped) visit(spec, value, path);
+        else if (fitsKind(value, spec.kind)) walk(spec, value, path);
+    }
+    return findings;
+}

package/engine/derived-sections.mjs

@@ -0,0 +1,322 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * The **derived sections** a note is given after its text, written as the
+ * Markdown every surface receives — see {@link module:engine/generated-sections}
+ * for the rules all generated sections share.
+ *
+ * | Section           | Anchor           | On                   | Lists                                                       |
+ * | ----------------- | ---------------- | -------------------- | ----------------------------------------------------------- |
+ * | Within            | `within`         | a place              | the places whose `parents` names it, grouped by kind         |
+ * | Governed by       | `governedby`     | a place              | the affiliation its `data.government` names                  |
+ * | Governed places   | `governedplaces` | an affiliation       | the places naming it as government, grouped by kind          |
+ * | In song and story | `insongandstory` | any note             | the works naming it, or one of its events, in `subjects`     |
+ * | From here         | `fromhere`       | a place on a border or a route | the map from it, as an image                       |
+ *
+ * The lists are the derivations {@link module:engine/holdings} and
+ * {@link module:engine/literature-works} make, over this package's records and
+ * every fetched index. An entry naming a note that publishes a page is a
+ * wikilink with an empty label, so each surface resolves it its own way and
+ * prints the note's current name; an entry naming a stub is its name as plain
+ * text.
+ *
+ * The map is the drawing `package-build map --from` makes. The section names
+ * it by {@link module:engine/generated-sections.fromHereSource}, and each
+ * surface draws and serves it.
+ *
+ * @module
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+    authoredSection,
+    fromHereFile,
+    fromHereSource,
+    sectionHeading,
+} from "./generated-sections.mjs";
+import { foreignHoldingsNodes, holdingsNode, holdingsPages } from "./holdings.mjs";
+import { isNoteRecord } from "./index-records.mjs";
+import { foreignWorksNodes, worksNode, worksPages } from "./literature-works.mjs";
+import { buildMaps, relatedPlaces } from "./map-build.mjs";
+import { mapWorld } from "./map-places.mjs";
+import { NOTE_VOCABULARY } from "./note-vocabulary.mjs";
+
+/**
+ * The heading each kind of place is grouped under, in the order the place
+ * vocabulary declares its kinds. A kind the vocabulary does not declare is
+ * grouped after these by its own name, and a place stating no kind last, under
+ * **Other**.
+ *
+ * @type {Readonly<Record<string, string>>}
+ */
+export const PLACE_KIND_LABELS = Object.freeze({
+    world: "Worlds",
+    region: "Regions",
+    settlement: "Settlements",
+    site: "Sites",
+    structure: "Structures",
+    feature: "Features",
+    celestial: "Celestial places",
+});
+
+/** The place kinds, in vocabulary order. */
+const PLACE_KINDS = NOTE_VOCABULARY.place.subTypes ?? [];
+
+/**
+ * A name set as plain Markdown text, its inline markup characters escaped.
+ *
+ * @param {string} text - A note's name.
+ * @returns {string} Text no surface reads as markup.
+ */
+function plain(text) {
+    return String(text ?? "").replace(/([\\`*_[\]<>{}|#!~])/g, "\\$1");
+}
+
+/**
+ * One entry: a wikilink to a note with a page, its name as text otherwise.
+ *
+ * @param {{title: string, url?: string, address?: string}} entry - From a
+ *   derivation.
+ * @returns {string} Markdown.
+ */
+function entryText(entry) {
+    return entry.url && entry.address ? `[[${entry.address}|]]` : plain(entry.title);
+}
+
+/**
+ * A kind's words as a reader meets them: `polity`, `noble house`.
+ *
+ * @param {string} kind - A `subType`.
+ * @returns {string} The words.
+ */
+function kindWords(kind) {
+    return String(kind)
+        .replace(/[-_]+/g, " ")
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .toLowerCase();
+}
+
+/**
+ * Places grouped by kind, a paragraph to each kind: `**Settlements:** A, B`.
+ *
+ * @param {Array<{title: string, url?: string, address?: string, subType?: string}>} entries -
+ *   Sorted by kind, then title.
+ * @returns {string} Markdown.
+ */
+function groupedPlaces(entries) {
+    const byKind = new Map();
+    for (const entry of entries) {
+        const kind = entry.subType ?? "";
+        if (!byKind.has(kind)) byKind.set(kind, []);
+        byKind.get(kind).push(entry);
+    }
+    const label = (kind) => {
+        if (!kind) return "Other";
+        if (PLACE_KIND_LABELS[kind]) return PLACE_KIND_LABELS[kind];
+        const words = kindWords(kind);
+        return words.charAt(0).toUpperCase() + words.slice(1);
+    };
+    const known = PLACE_KINDS.filter((kind) => byKind.has(kind));
+    const others = [...byKind.keys()]
+        .filter((kind) => kind && !PLACE_KINDS.includes(kind))
+        .sort((a, b) => label(a).localeCompare(label(b), "en"));
+    const order = [...known, ...others, ...(byKind.has("") ? [""] : [])];
+    return order
+        .map((kind) => `**${label(kind)}:** ${byKind.get(kind).map(entryText).join(", ")}`)
+        .join("\n\n");
+}
+
+/**
+ * A list, one entry to a line, with its kind or form after it in parentheses.
+ *
+ * @param {Array<{title: string, url?: string, address?: string}>} entries
+ * @param {(entry: object) => string|undefined} detail - What follows the name.
+ * @returns {string} Markdown.
+ */
+function listed(entries, detail) {
+    return entries
+        .map((entry) => {
+            const after = detail(entry);
+            return `- ${entryText(entry)}${after ? ` (${plain(after)})` : ""}`;
+        })
+        .join("\n");
+}
+
+/**
+ * A section's Markdown: its heading, with its anchor, and its content.
+ *
+ * @param {string} slug - The section.
+ * @param {string} content - What it shows.
+ * @returns {string} The section.
+ */
+function section(slug, content) {
+    return `${sectionHeading(slug)}\n\n${content}\n`;
+}
+
+/**
+ * The note's name, as the derivations title an entry.
+ *
+ * @param {object} record - An index record.
+ * @returns {string} The name.
+ */
+function titleOf(record) {
+    return String(record.name?.full ?? record.shortcode ?? "");
+}
+
+/**
+ * The places of this package that are given the map from them: each one that
+ * states, or is named in, a border or a route, and publishes a page.
+ *
+ * @param {object[]} records - The content-index records.
+ * @param {object} [opts]
+ * @param {Map<string, object>} [opts.foreignIndex] - The fetched indexes, whose
+ *   places a local place's border or route may name.
+ * @param {object} [opts.config] - The resolved configuration. `site.maps:
+ *   false` gives no place a map.
+ * @returns {string[]} The places' shortcodes, sorted.
+ */
+export function placesWithMaps(records, { foreignIndex = new Map(), config } = {}) {
+    if (config?.site?.maps === false) return [];
+    const world = mapWorld({
+        records: records.filter((record) => isNoteRecord(record)),
+        foreignIndex,
+        contentBase: config?.paths?.content ?? "",
+        config,
+    });
+    const published = new Set(
+        records
+            .filter((record) => isNoteRecord(record) && record.type === "place" && record.address)
+            .map((record) => String(record.shortcode).toLowerCase()),
+    );
+    return relatedPlaces(world.places).filter(
+        (shortcode) => world.places.get(shortcode)?.local && published.has(shortcode),
+    );
+}
+
+/**
+ * Draw the map from each place given one, for a surface that serves the
+ * drawing as a file: the Foundry compile and the book. Each drawing is the
+ * standalone SVG `package-build map --from` writes, with no links, since
+ * neither surface follows a link inside a picture.
+ *
+ * @param {object[]} records - The content-index records.
+ * @param {object} opts
+ * @param {string} opts.outDir - Where to draw. Emptied first, so a place that
+ *   lost its relations keeps no drawing from an earlier run.
+ * @param {Map<string, object>} [opts.foreignIndex] - The fetched indexes.
+ * @param {object} [opts.config] - The resolved configuration.
+ * @param {Iterable<string>} [opts.only] - The places to draw, of those given a
+ *   map; absent, every one.
+ * @returns {{maps: Map<string, string>, findings: object[]}} Each drawing's
+ *   file, keyed by the file name a **From here** section names, and what
+ *   drawing found.
+ */
+export function drawMapsFrom(records, { outDir, foreignIndex = new Map(), config, only } = {}) {
+    fs.rmSync(outDir, { recursive: true, force: true });
+    const wanted = only ? new Set([...only].map((one) => String(one).toLowerCase())) : null;
+    const centres = placesWithMaps(records, { foreignIndex, config }).filter(
+        (shortcode) => !wanted || wanted.has(shortcode),
+    );
+    /** @type {Map<string, string>} */
+    const maps = new Map();
+    if (!centres.length) return { maps, findings: [] };
+    const world = mapWorld({
+        records: records.filter((record) => isNoteRecord(record)),
+        foreignIndex,
+        contentBase: config?.paths?.content ?? "",
+        config,
+    });
+    const { findings } = buildMaps({ world, outDir, from: centres });
+    for (const centre of centres) {
+        const name = fromHereFile(centre);
+        maps.set(name, path.join(outDir, name));
+    }
+    return { maps, findings };
+}
+
+/**
+ * The derived sections each note is given.
+ *
+ * @param {object[]} records - The content-index records, of the audience the
+ *   surface publishes to.
+ * @param {object} opts
+ * @param {(record: object) => string} opts.fileOf - A record's note file, as
+ *   prepared results are keyed.
+ * @param {Map<string, object>} [opts.foreignIndex] - The fetched indexes.
+ * @param {object} [opts.config] - The resolved configuration.
+ * @param {string} [opts.only] - One note file to give sections to; absent,
+ *   every note.
+ * @returns {Map<string, Map<string, string>>} Note file to its sections, each
+ *   keyed by its slug, for every note given at least one.
+ */
+export function derivedSections(records, { fileOf, foreignIndex = new Map(), config, only }) {
+    const notes = records.filter((record) => isNoteRecord(record) && record.shortcode);
+    const pages = notes.filter((record) => record.address);
+    const nodeOf = (record) => ({
+        title: titleOf(record),
+        ...(record.address ? { url: record.address.canonical } : {}),
+        package: String(record.package ?? config?.contentPackage ?? ""),
+        ...(record.address ? { canonical: record.address.canonical } : {}),
+    });
+
+    // A stub publishes no page and is listed as plain text, so it takes part
+    // in every list without being given one.
+    const holdings = holdingsPages([
+        ...notes.map((record) => holdingsNode(record, nodeOf(record))),
+        ...foreignHoldingsNodes(foreignIndex),
+    ]);
+    const works = worksPages(
+        [
+            ...notes.map((record) => worksNode(record, nodeOf(record))),
+            ...foreignWorksNodes(foreignIndex),
+        ],
+        { types: new Set(Object.keys(NOTE_VOCABULARY)) },
+    );
+    const mapped = new Set(placesWithMaps(notes, { foreignIndex, config }));
+
+    const out = new Map();
+    for (const record of pages) {
+        if (only !== undefined && fileOf(record) !== only) continue;
+        const key = record.address.canonical;
+        const lists = holdings.get(key) ?? {};
+        const sections = new Map();
+        const add = (slug, content) => {
+            if (content && !authoredSection(record, slug))
+                sections.set(slug, section(slug, content));
+        };
+        if (lists.contains?.length) add("within", groupedPlaces(lists.contains));
+        if (lists.governed_by?.length)
+            add(
+                "governedby",
+                listed(lists.governed_by, (entry) => entry.subType && kindWords(entry.subType)),
+            );
+        if (lists.governed_places?.length)
+            add("governedplaces", groupedPlaces(lists.governed_places));
+        const written = works.get(key)?.works ?? [];
+        if (written.length)
+            add(
+                "insongandstory",
+                listed(written, (entry) => entry.form),
+            );
+        const shortcode = String(record.shortcode).toLowerCase();
+        if (record.type === "place" && mapped.has(shortcode)) {
+            const alt = `Map from ${titleOf(record)}`.replace(/[[\]]/g, "");
+            add("fromhere", `![${alt}](${fromHereSource(shortcode)}){.full-width}`);
+        }
+        if (sections.size) out.set(fileOf(record), sections);
+    }
+    return out;
+}