@heroiclands/package-build 25.5.4 → 25.6.0

package/engine/core-report.mjs

@@ -79,7 +79,7 @@ function idsOf(word) {
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @param {{language?: string}} [options] - A language to report alone, by its
  *   name, shortcode or reference slug whether or not it states `data.core`.
- * @returns {{concepts: number, languages: Array<{name: string, language: string, core: boolean, total: number, covered: number, missing: Array<{group: string, count: number, total: number, concepts: Array<{id: string, gloss: string}>}>}>}|{problem: string, about: string}}
+ * @returns {{concepts: number, notCovered: string[], languages: Array<{name: string, language: string, core: boolean, total: number, covered: number, missing: Array<{group: string, count: number, total: number, concepts: Array<{id: string, gloss: string}>}>}>}|{problem: string, about: string}}
  *   The report, or the problem when there is no concept list or the language
  *   asked for is none.
  */
@@ -113,6 +113,13 @@ export function coreReport(records, { language } = {}) {
     const groups = [...new Set(concepts.map((concept) => concept.group))];
     return {
         concepts: concepts.length,
+        notCovered:
+            language === undefined ?
+                languages
+                    .filter((record) => record.data?.core !== true)
+                    .map(nameOf)
+                    .sort((a, b) => a.localeCompare(b))
+            :   [],
         languages: chosen.map((record) => {
             const have = new Set();
             const forms = new Set();
@@ -154,24 +161,26 @@ export function coreReport(records, { language } = {}) {
  * A core report as text: one block per language, its missing concepts under
  * their groups with counts, each concept's id and gloss tab-separated.
  *
- * @param {{concepts: number, languages: Array<object>}} report - A report from {@link coreReport}.
+ * The default report ends with the names of languages it does not measure.
+ *
+ * @param {{concepts: number, notCovered: string[], languages: Array<object>}} report - A report from {@link coreReport}.
  * @returns {string} The text, ending in a newline.
  */
 export function coreReportText(report) {
-    if (!report.languages.length) return "No language states `data.core: true`.\n";
-    return report.languages
-        .map((one) => {
-            if (!one.missing.length)
-                return `${one.name} (${one.language}): all ${one.total} core concepts have a word\n`;
-            const lines = [
-                `${one.name} (${one.language}): ${one.total - one.covered} of ${one.total} core concepts have no word`,
-            ];
-            for (const group of one.missing) {
-                lines.push(`  ${group.group}: ${group.count} of ${group.total}`);
-                for (const concept of group.concepts)
-                    lines.push(`    ${concept.id}\t${concept.gloss}`);
-            }
-            return `${lines.join("\n")}\n`;
-        })
-        .join("\n");
+    const blocks = report.languages.map((one) => {
+        if (!one.missing.length)
+            return `${one.name} (${one.language}): all ${one.total} core concepts have a word\n`;
+        const lines = [
+            `${one.name} (${one.language}): ${one.total - one.covered} of ${one.total} core concepts have no word`,
+        ];
+        for (const group of one.missing) {
+            lines.push(`  ${group.group}: ${group.count} of ${group.total}`);
+            for (const concept of group.concepts) lines.push(`    ${concept.id}\t${concept.gloss}`);
+        }
+        return `${lines.join("\n")}\n`;
+    });
+    if (!blocks.length) blocks.push("No language states `data.core: true`.\n");
+    if (report.notCovered.length)
+        blocks.push(`Not covered (no data.core): ${report.notCovered.join(", ")}\n`);
+    return blocks.join("\n");
 }

package/engine/culture-reach.mjs

@@ -345,6 +345,9 @@ export function noteTerms(index, note, entry) {
  * in a tree that describes peoples. Its ranks and offices then have no
  * culture associations for term queries.
  *
+ * The note's `data.culture` is the culture the content index resolved for it:
+ * its own, else the one its `data.parents` chain agrees on.
+ *
  * @param {object} note - An `affiliation` note.
  * @param {{index?: object}} [context]
  * @returns {object[]} One warning, at the note's `type`, or none.

package/engine/declared-sections.mjs

@@ -0,0 +1,100 @@
+/*
+ * 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
+ */
+/** Place declared content in its authored section, or create that section. */
+import { scanHeadingAttributes } from "./heading-attributes.mjs";
+import { scanBlocks } from "./content-blocks.mjs";
+
+/** Authored headings, excluding literal examples and named containers. */
+export function declaredHeadings(markdown, syntax) {
+    const blocks = (syntax ? syntax(markdown).blocks : scanBlocks(markdown)).blocks;
+    return scanHeadingAttributes(markdown).headings.filter(
+        (heading) =>
+            !blocks.some(
+                (block) => heading.line - 1 >= block.start && heading.line - 1 <= block.end,
+            ),
+    );
+}
+
+/**
+ * Insert indexed content at its heading while preserving subsequent source lines.
+ * @param {string} markdown - Expanded body.
+ * @param {Array<{slug:string,heading:string,markdown:string}>} [sections] - Declared content.
+ * @param {{authored?:string,lineMap?:object[],generatedFrom?:number,syntax?:Function}} [context] - Captured source mappings.
+ * @returns {{markdown:string,lineMap:object[],generatedFrom?:number}} Expanded body and locations.
+ */
+export function insertDeclaredSections(
+    markdown,
+    sections = [],
+    { authored = markdown, lineMap, generatedFrom, syntax } = {},
+) {
+    const lines = String(markdown ?? "").split("\n");
+    const locations = lineMap ? [...lineMap] : lines.map((_, line) => ({ line, generated: false }));
+    if (!sections.length)
+        return {
+            markdown: lines.join("\n"),
+            lineMap: locations,
+            ...(generatedFrom === undefined ? {} : { generatedFrom }),
+        };
+    const headings = declaredHeadings(authored, syntax)
+        .map((heading) => ({
+            ...heading,
+            sourceLine: heading.line - 1,
+            line: locations.findIndex(
+                (location, at) =>
+                    location.line === heading.line - 1 &&
+                    !location.generated &&
+                    (generatedFrom === undefined || at < generatedFrom),
+            ),
+        }))
+        .filter((h) => h.line >= 0);
+    const edits = [];
+    for (const section of sections) {
+        const own = headings.find((h) => h.id === section.slug || h.text === section.heading);
+        const next = own && headings.find((h) => h.line > own.line && h.level <= own.level);
+        const at = next?.line ?? generatedFrom ?? lines.length;
+        if (own && !own.id) {
+            const line = lines[own.line].replace(/\s*#*\s*$/, "");
+            lines[own.line] =
+                /\{[^{}]*\}$/.test(line) ?
+                    line.replace(/\}$/, ` #${section.slug}}`)
+                :   line + ` {#${section.slug}}`;
+        }
+        edits.push({
+            at,
+            source: own?.sourceLine ?? Math.max(0, String(authored).split("\n").length - 1),
+            lines: [
+                "",
+                ...(own ?
+                    section.markdown
+                :   `# ${section.heading} {#${section.slug}}\n\n${section.markdown}`
+                ).split("\n"),
+                "",
+            ],
+        });
+    }
+    for (const edit of edits.sort((a, b) => b.at - a.at)) {
+        lines.splice(edit.at, 0, ...edit.lines);
+        locations.splice(
+            edit.at,
+            0,
+            ...edit.lines.map(() => ({ line: edit.source, generated: true })),
+        );
+        if (generatedFrom !== undefined && edit.at <= generatedFrom)
+            generatedFrom += edit.lines.length;
+    }
+    return {
+        markdown: lines.join("\n"),
+        lineMap: locations,
+        ...(generatedFrom === undefined ? {} : { generatedFrom }),
+    };
+}

package/engine/derived-sections.mjs

@@ -21,10 +21,12 @@
  * | 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          |
+ * | Office holders    | `officeholders`  | an affiliation       | each declared office's living holders, from the beings' own `office` |
  * | 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
+ * The lists are the derivations {@link module:engine/holdings},
+ * {@link module:engine/office-holders} 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
@@ -39,6 +41,7 @@
  */
 
 import fs from "node:fs";
+import { assertSettlementRecords, settlementMarkdown } from "./settlement-tables.mjs";
 import path from "node:path";
 
 import {
@@ -52,6 +55,8 @@ 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 { officeBodyKey, officeHolders } from "./office-holders.mjs";
+import { renderAddress } from "./address.mjs";
 import { NOTE_VOCABULARY } from "./note-vocabulary.mjs";
 
 /**
@@ -65,10 +70,12 @@ import { NOTE_VOCABULARY } from "./note-vocabulary.mjs";
 export const PLACE_KIND_LABELS = Object.freeze({
     world: "Worlds",
     region: "Regions",
+    district: "Districts",
     settlement: "Settlements",
     site: "Sites",
     structure: "Structures",
     feature: "Features",
+    route: "Routes",
     celestial: "Celestial places",
 });
 
@@ -166,6 +173,22 @@ function section(slug, content) {
     return `${sectionHeading(slug)}\n\n${content}\n`;
 }
 
+/**
+ * A body's offices, one line each, with the beings holding each.
+ *
+ * @param {Map<string, object[]>} held - Office → its holders' records.
+ * @returns {string} Markdown.
+ */
+function officeLines(held) {
+    const holder = (record) =>
+        record.address ?
+            `[[${renderAddress({ ...record.address.canonical, system: "note" })}|]]`
+        :   plain(titleOf(record));
+    return [...held]
+        .map(([office, holders]) => `- **${plain(office)}:** ${holders.map(holder).join(", ")}`)
+        .join("\n");
+}
+
 /**
  * The note's name, as the derivations title an entry.
  *
@@ -257,12 +280,18 @@ export function drawMapsFrom(records, { outDir, foreignIndex = new Map(), config
  *   prepared results are keyed.
  * @param {Map<string, object>} [opts.foreignIndex] - The fetched indexes.
  * @param {object} [opts.config] - The resolved configuration.
+ * @param {(file:string)=>string|undefined} [opts.rawOf] - Captured source locators.
+ * @param {object[]} [opts.all=records] - Complete records for settlement validation.
  * @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 }) {
+export function derivedSections(
+    records,
+    { fileOf, foreignIndex = new Map(), config, only, rawOf, all = records },
+) {
+    assertSettlementRecords(all, { fileOf, foreignIndex, rawOf });
     const notes = records.filter((record) => isNoteRecord(record) && record.shortcode);
     const pages = notes.filter((record) => record.address);
     const nodeOf = (record) => ({
@@ -286,6 +315,7 @@ export function derivedSections(records, { fileOf, foreignIndex = new Map(), con
         { types: new Set(Object.keys(NOTE_VOCABULARY)) },
     );
     const mapped = new Set(placesWithMaps(notes, { foreignIndex, config }));
+    const offices = officeHolders(notes);
 
     const out = new Map();
     for (const record of pages) {
@@ -297,6 +327,8 @@ export function derivedSections(records, { fileOf, foreignIndex = new Map(), con
             if (content && !authoredSection(record, slug))
                 sections.set(slug, section(slug, content));
         };
+        const settlements = settlementMarkdown(record);
+        if (settlements) sections.set("settlements", section("settlements", settlements));
         if (lists.contains?.length) add("within", groupedPlaces(lists.contains));
         if (lists.governed_by?.length)
             add(
@@ -305,6 +337,8 @@ export function derivedSections(records, { fileOf, foreignIndex = new Map(), con
             );
         if (lists.governed_places?.length)
             add("governedplaces", groupedPlaces(lists.governed_places));
+        const held = record.type === "affiliation" && offices.get(officeBodyKey(record));
+        if (held) add("officeholders", officeLines(held));
         const written = works.get(key)?.works ?? [];
         if (written.length)
             add(

package/engine/dictionary-rows.mjs

@@ -49,6 +49,7 @@
  */
 
 import { pluralOf, pluralByRule } from "./word-inflections.mjs";
+import { standingOffices } from "./standings.mjs";
 export { pluralOf, pluralByRule } from "./word-inflections.mjs";
 import { createHash } from "node:crypto";
 import { parseAddress, renderAddress } from "./address.mjs";
@@ -393,7 +394,7 @@ export function dictionaryAndTermRows(records, all = records) {
                     :   [];
                 add("office", title, isMap(office) ? office.description : office, [
                     ...holders,
-                    ...membersOf(body, (standing) => standing.office === title),
+                    ...membersOf(body, (standing) => standingOffices(standing).includes(title)),
                 ]);
             }
         governance.set(body, rows);

package/engine/generated-sections.mjs

@@ -57,9 +57,11 @@ export const CHRONOLOGY_SLUG = "chronology";
  */
 export const GENERATED_SECTIONS = Object.freeze(
     [
+        { slug: "settlements", heading: "Settlements" },
         { slug: "within", heading: "Within" },
         { slug: "governedby", heading: "Governed by" },
         { slug: "governedplaces", heading: "Governed places" },
+        { slug: "officeholders", heading: "Office holders" },
         { slug: CHRONOLOGY_SLUG, heading: "Chronology" },
         { slug: "events", heading: "Events" },
         { slug: "accounts", heading: "Accounts" },

package/engine/holdings.mjs

@@ -14,7 +14,9 @@
 /**
  * Derive containment and government lists from place facts. Geography comes
  * only from `data.parents`; government comes only from `data.government`.
- * Neither graph expands through geographic or affiliation ancestors. Government identity preserves the Address package, type and shortcode.
+ * Neither graph expands through affiliation ancestors, and government expands
+ * through geographic ones only for a district stating none, which the content
+ * index resolves before these lists read it. Government identity preserves the Address package, type and shortcode.
  * Its system normalizes to `note` because Item and journal documents share one page.
  * The lists become a note's generated **Within**, **Governed by** and
  * **Governed places** sections — see {@link module:engine/derived-sections}.
@@ -255,6 +257,106 @@ export function holdingsPages(nodes, { governmentNodes = [] } = {}) {
     return lists;
 }
 
+/* --------------------------------------------------------------------- */
+/*  A district's government                                               */
+/* --------------------------------------------------------------------- */
+
+/** Districts whose government the index supplied from a parent. */
+const inheritedGovernment = new WeakSet();
+
+/**
+ * Whether a record's `data.government` came from a parent rather than its own
+ * note.
+ *
+ * @param {object} record - An index record.
+ * @returns {boolean} True for a district that inherited its government.
+ */
+export function governmentInherited(record) {
+    return inheritedGovernment.has(record);
+}
+
+/**
+ * Give each district that states no government its parent's.
+ *
+ * A `place/district` falls under the government of the place it stands
+ * within. One stating no `data.government` key takes the value of its nearest
+ * parent that states the key, walking `data.parents` breadth first, in the
+ * order written, through any parent that states none, and never visiting a
+ * place twice. An explicit value on the district, `null` (complete anarchy)
+ * included, is its own and is kept; a parent's explicit `null` is inherited as
+ * anarchy. Every reader of the index — the Governed by and Governed places
+ * sections, the "missing government" advisory, a consumer of the published
+ * index — then reads the effective government at `data.government`.
+ *
+ * @param {object[]} records - Content-index records, edited in place.
+ * @param {object} [opts]
+ * @param {(key: string) => object|undefined} [opts.foreignRecord] - A fetched
+ *   index's record by canonical Address, for a parent in a dependency.
+ * @returns {void}
+ */
+export function inheritDistrictGovernments(records, { foreignRecord } = {}) {
+    const keyOf = (pkg, shortcode) =>
+        renderAddress({
+            package: String(pkg ?? "local"),
+            system: "note",
+            type: "place",
+            shortcode: String(shortcode).toLowerCase(),
+        });
+    const places = new Map();
+    for (const record of records) {
+        if (record?.type !== "place" || record.documents || !record.shortcode) continue;
+        const key = keyOf(record.package, record.shortcode);
+        if (!places.has(key)) places.set(key, record);
+    }
+    const parentKeys = (record) => {
+        const parents = record?.data?.parents ?? record?.parents;
+        const list =
+            Array.isArray(parents) ? parents
+            : parents == null ? []
+            : [parents];
+        return list
+            .map((value) => {
+                if (isAddressTuple(value)) return keyOf(value.package, value.shortcode);
+                const tuple =
+                    readCanonicalKey(String(value ?? "")) ??
+                    parseAddress(value, {
+                        package: record.package ?? "local",
+                        system: "note",
+                        type: "place",
+                        types: new Set(["place"]),
+                    });
+                return isAddressTuple(tuple) ? keyOf(tuple.package, tuple.shortcode) : "";
+            })
+            .filter(Boolean);
+    };
+    const stated = (record) => {
+        const data = record?.data && typeof record.data === "object" ? record.data : record;
+        return data && Object.hasOwn(data, "government") && !inheritedGovernment.has(record) ?
+                { value: data.government }
+            :   undefined;
+    };
+    for (const district of places.values()) {
+        if (district.subType !== "district") continue;
+        const data = district.data && typeof district.data === "object" ? district.data : {};
+        if (Object.hasOwn(data, "government")) continue;
+        const seen = new Set([keyOf(district.package, district.shortcode)]);
+        const queue = parentKeys(district);
+        let found;
+        while (queue.length && !found) {
+            const key = queue.shift();
+            if (seen.has(key)) continue;
+            seen.add(key);
+            const parent = places.get(key) ?? foreignRecord?.(key);
+            if (!parent) continue;
+            found = stated(parent);
+            if (!found) queue.push(...parentKeys(parent));
+        }
+        if (!found) continue;
+        district.data = { ...data, government: found.value };
+        inheritedGovernment.add(district);
+    }
+}
+
 /* --------------------------------------------------------------------- */
 /*  The lint                                                              */
 /* --------------------------------------------------------------------- */
@@ -264,8 +366,10 @@ export function holdingsPages(nodes, { governmentNodes = [] } = {}) {
  * Missing, null or zero population establishes no inhabited population.
  * Property presence distinguishes omitted government from explicit null,
  * which means complete anarchy. Non-null values are validated by the declared
- * affiliation reference field. Neither geographic containment nor tenure
- * supplies this fact, and the rule is independent of place subtype.
+ * affiliation reference field. Tenure never supplies this fact, and
+ * containment supplies it only to a district, which the content index gives
+ * its nearest parent's government (see {@link inheritDistrictGovernments}), so
+ * a district under a governed place is never advised.
  *
  * @param {object} note - The note with parsed frontmatter and raw source.
  * @returns {object[]} Located warning findings.

package/engine/index-records.mjs

@@ -42,7 +42,8 @@ import { isAddressTuple } from "./address.mjs";
  * since a note declaring its own is a hard error — and it matches what
  * the content-table expander puts on the same field, so a query reads the same
  * value from either. `file` namespaces the note's place in the tree, again
- * matching the expander's `file.*`.
+ * matching the expander's `file.*`. `officeHolders` lists, on a body, the
+ * living beings whose own standing names each of its offices.
  *
  * Both are checked rather than assumed: `folder` is real frontmatter on most
  * notes, so the neighbouring names are close enough to a real key that a silent
@@ -68,6 +69,7 @@ export const DERIVED_KEYS = Object.freeze([
     "citations",
     "names",
     "runs",
+    "officeHolders",
 ]);
 
 /**

package/engine/index.mjs

@@ -103,7 +103,7 @@ export * as populations from "./populations.mjs";
 /** What trade a settlement supports: the six-step market scale, and the check that holds a value to it. */
 export * as marketClass from "./market-class.mjs";
 
-/** A region's settlements table: the holding models, the columns, and the check that holds a table to them. */
+/** A region's settlements table: its rows, the columns, and the check that holds a table to them. */
 export * as settlementTables from "./settlement-tables.mjs";
 
 /** The places a map is drawn from, read from the content index, and what `parents` says about them. */

package/engine/language-data.mjs

@@ -1071,7 +1071,6 @@ export function checkLanguageData(note, { index, types } = {}) {
     for (const kind of SCOPE_KINDS) {
         listOf(scope[kind]).forEach((value, i) => {
             const path = ["data", "scope", kind, i];
-            if (kind === "paths") return;
             if (kind === "types") {
                 if (types && typeof value === "string" && !types.includes(value))
                     findings.push(finding(path, "error", `\`${value}\` is not a note type`));

package/engine/language-names.mjs

@@ -29,11 +29,11 @@
  *   tongue whose forms differ by gender states a map of gender words to a
  *   pattern or a list of them. A gender with no pattern of its own takes every
  *   pattern stated.
- * - `given` — given names, one list per gender word of the closed gender
- *   vocabulary. `female` and `male` are required. `{given}` draws from the
- *   person's gender's list, or from every given list together where that gender
- *   has none; `{given.<gender>}` draws from that gender's list whatever the
- *   person's gender, as a patronymic draws a father's name.
+ * - `given` — one list of names for everyone, or a map of gender words to
+ *   lists. The map requires `female` and `male`. `{given}` draws from the shared
+ *   list, the person's gender's list, or every given list together where that
+ *   gender has none. `{given.<gender>}` draws from the shared list or that
+ *   gender's list whatever the person's gender, as a patronymic draws a father's name.
  * - `en` — English names, in groups of lists: `en.epithet` is a list a pattern
  *   draws from as `{en.epithet}`, as `"{given} the {en.epithet}"` does. English
  *   names are never encoded in the tongue's script or checked against its
@@ -73,7 +73,7 @@ const LIST_NAME = /^[A-Za-z][A-Za-z0-9_]*$/;
 const PLACEHOLDER = /^([A-Za-z][A-Za-z0-9_]*)(?:\.([A-Za-z][A-Za-z0-9_]*))?$/;
 
 /**
- * The genders every `data.names.given` states a list for.
+ * The genders a mapped `data.names.given` states a list for.
  *
  * A function rather than a `const`: `note-vocabulary.mjs` reads it while the
  * module graph is still evaluating.
@@ -317,8 +317,12 @@ export function namesProblems(names, lookVocabulary) {
 
     const given = names[GIVEN_LIST];
     if (given === undefined || given === null) shape([], "`data.names` must state `given`", true);
+    else if (Array.isArray(given)) checkList([GIVEN_LIST]);
     else if (!isPlainMap(given))
-        shape([GIVEN_LIST], `\`${label([GIVEN_LIST])}\` should be a map of genders to lists`);
+        shape(
+            [GIVEN_LIST],
+            `\`${label([GIVEN_LIST])}\` should be a list of names or a map of genders to lists`,
+        );
     else {
         const genders = genderWords(lookVocabulary);
         for (const gender of requiredGivenGenders()) {
@@ -428,7 +432,18 @@ export function namesProblems(names, lookVocabulary) {
             }
             named.add(part.list);
             if (part.gender !== undefined) {
-                if (givenMap[part.gender] === undefined || givenMap[part.gender] === null)
+                if (Array.isArray(given)) {
+                    if (!genders.includes(part.gender)) {
+                        const guess = nearest(part.gender, genders);
+                        problem(
+                            path,
+                            `${JSON.stringify(part.gender)} is not a gender; ` +
+                                `\`{${placeholderText(part)}}\` in \`${label(path)}\` takes ` +
+                                genders.join(", ") +
+                                (guess ? `. Did you mean "${guess}"?` : ""),
+                        );
+                    }
+                } else if (givenMap[part.gender] === undefined || givenMap[part.gender] === null)
                     problem(
                         path,
                         `\`{${placeholderText(part)}}\` in \`${label(path)}\` names no list: ` +
@@ -476,7 +491,7 @@ export function namesProblems(names, lookVocabulary) {
  * keys cannot: a pattern that does not parse, a placeholder naming no list, a
  * list no pattern names, a list name a placeholder cannot spell, an empty list
  * of patterns or of names, an empty name, a pattern or given list keyed by no
- * gender, and a missing `female` or `male` list. Each is located at the pattern, list, entry or key at fault.
+ * gender, and a missing `female` or `male` list in a gender map. Each is located at the pattern, list, entry or key at fault.
  *
  * @param {object} note - The note: `file`, `raw` and parsed `fm`.
  * @param {Readonly<Record<string, readonly {value: string}[]>>} lookVocabulary -
@@ -534,8 +549,8 @@ export function namesFindings(note, lookVocabulary) {
 }
 
 /**
- * The given names a gender draws from: its own list, or every given list
- * together where it has none.
+ * The given names a gender draws from: the shared list, its own list, or
+ * every given list together where it has none.
  *
  * @param {object} names - Checked `data.names`.
  * @param {string} gender - A gender word.
@@ -543,6 +558,7 @@ export function namesFindings(note, lookVocabulary) {
  */
 export function givenNames(names, gender) {
     const given = names[GIVEN_LIST];
+    if (Array.isArray(given)) return given;
     if (Array.isArray(given[gender])) return given[gender];
     return [...new Set(Object.values(given).filter(Array.isArray).flat())];
 }
@@ -551,29 +567,42 @@ export function givenNames(names, gender) {
 function listFor(names, part, gender) {
     if (part.sub !== undefined) return names[part.list][part.sub];
     if (part.list !== GIVEN_LIST) return names[part.list];
-    if (part.gender !== undefined) return names[GIVEN_LIST][part.gender];
+    if (part.gender !== undefined) return givenNames(names, part.gender);
     return givenNames(names, gender);
 }
 
 /**
- * A name drawn from a language's lists: one of the gender's patterns, where it
- * has more than one, then each placeholder an even draw from its list.
+ * A name's selected literal and placeholder parts. One of the gender's
+ * patterns is selected first, then each placeholder is an even draw from its
+ * source list.
  *
  * @param {object} names - Checked `data.names`.
  * @param {string} gender - A gender word.
  * @param {() => number} next - A stream of numbers in `[0, 1)`.
- * @returns {string} The name.
+ * @returns {(PatternPart & {text: string})[]} The selected parts in pattern order.
  */
-export function drawName(names, gender, next) {
+export function drawNameParts(names, gender, next) {
     const patterns = patternsFor(names, gender);
     const pattern =
         patterns.length > 1 ? patterns[Math.floor(next() * patterns.length)] : patterns[0];
-    return parsePattern(pattern)
-        .parts.map((part) => {
-            if ("literal" in part) return part.literal;
-            const list = listFor(names, part, gender);
-            return list[Math.floor(next() * list.length)];
-        })
+    return parsePattern(pattern).parts.map((part) => {
+        if ("literal" in part) return { ...part, text: part.literal };
+        const list = listFor(names, part, gender);
+        return { ...part, text: list[Math.floor(next() * list.length)] };
+    });
+}
+
+/**
+ * A name drawn from a language's lists.
+ *
+ * @param {object} names - Checked `data.names`.
+ * @param {string} gender - A gender word.
+ * @param {() => number} next - A stream of numbers in `[0, 1)`.
+ * @returns {string} The name.
+ */
+export function drawName(names, gender, next) {
+    return drawNameParts(names, gender, next)
+        .map((part) => part.text)
         .join("");
 }
 
@@ -640,7 +669,8 @@ export function nameMisfit(full, names, gender) {
     const text = nfc(full);
     const given = names[GIVEN_LIST];
     const own = givenNames(names, gender).map(nfc);
-    const every = Object.values(given).filter(Array.isArray).flat().map(nfc);
+    const every = (
+        Array.isArray(given) ? given : Object.values(given).filter(Array.isArray).flat()).map(nfc);
     const lookup = (forGiven) => (part) =>
         part.list === GIVEN_LIST && part.gender === undefined ?
             forGiven

package/engine/language-rows.mjs

@@ -413,14 +413,12 @@ export function inScope(record, address, scope) {
         const wanted = values(kind);
         return strings(list).some((one) => wanted.has(one));
     };
-    const file = typeof record.file?.path === "string" ? record.file.path : "";
     return (
         values("addresses").has(address) ||
         any("folders", data.packFolder) ||
         any("cultures", data.culture) ||
         any("lore", data.lore) ||
-        any("parents", data.parents) ||
-        strings(scope.paths).some((prefix) => file.startsWith(prefix))
+        any("parents", data.parents)
     );
 }