@heroiclands/package-build 25.5.5 → 25.6.0

package/engine/content-index.mjs

@@ -141,6 +141,8 @@ import { EXPRESSION, renderMarkdownExpressions } from "./markdown-expressions.mj
 import { scanFigures } from "./content-figures.mjs";
 import { eventNoteIndex } from "./event-fields.mjs";
 import { derivedSections } from "./derived-sections.mjs";
+import { officeBodyKey, officeHolders } from "./office-holders.mjs";
+import { inheritDistrictGovernments } from "./holdings.mjs";
 // One reader for a note's anchors, shared with the link checker and with the
 // builds that emit a link. Re-exported because this is where callers
 // have always addressed it.
@@ -1311,6 +1313,8 @@ export function collectContentIndex(
         parsed,
     });
     resolveCultures(records, { contentPackage, contentBase, foreignRecord, problems, parsed });
+    // A district stating no government falls under its parent's.
+    inheritDistrictGovernments(records, { foreignRecord });
     const cultureNotes = records
         .filter((record) => isNoteRecord(record) && record.type === "lore")
         .map((record) => ({
@@ -1333,6 +1337,24 @@ export function collectContentIndex(
     for (const [note, inherited] of inheritance.values)
         if (Object.keys(inherited).length) note.fm.data = { ...note.fm.data, ...inherited };
 
+    // An office's holders are the living beings naming it, read once every
+    // being is recorded. A public body lists only public beings, as its page
+    // does.
+    phase("index office holders");
+    const publicHolders = officeHolders(records.filter((record) => !isGmNote(record)));
+    const allHolders = officeHolders(records);
+    for (const record of records) {
+        if (!isNoteRecord(record) || record.type !== "affiliation") continue;
+        const held = (isGmNote(record) ? allHolders : publicHolders).get(officeBodyKey(record));
+        if (!held) continue;
+        record.officeHolders = [...held].map(([office, holders]) => ({
+            office,
+            holders: holders.map((being) =>
+                readCanonicalKey(canonicalKey(being.package, "note", "being", being.shortcode)),
+            ),
+        }));
+    }
+
     // Automatic lexical sections require only the recorded frontmatter. Their
     // published anchors and journal targets therefore use the same pure body
     // projection as the surfaces, without making the index emitter async.
@@ -1924,6 +1946,7 @@ export function emitContentIndex({ contentBase, outDir, config, publication } =
                 record.data?.events?.length,
         ) ||
             derivedSections(notes, {
+                rawOf: (file) => parsed.get(file)?.raw,
                 fileOf: (record) => noteFile(tree, record),
                 config: resolved,
                 foreignIndex: loadForeignIndexes(resolved, [contentPackage]).index,

package/engine/content-links.mjs

@@ -56,6 +56,7 @@ import { readWikilink } from "./wikilink-syntax.mjs";
 import { encodeAddresses } from "./address-values.mjs";
 import fs from "node:fs";
 import { cultureRecordProblems, cultureInheritedFields } from "./culture-parents.mjs";
+import { governmentInherited } from "./holdings.mjs";
 import path from "node:path";
 
 import { matchAllOutsideCode } from "./code-fences.mjs";
@@ -248,6 +249,13 @@ export function buildLinkIndex(
         if (typeof record.languageCode === "string") note.languageCode = record.languageCode;
         const hierarchyProblems = cultureRecordProblems(record);
         note.inheritedCultureFields = cultureInheritedFields(record);
+        // A district's government taken from its parent is the parent's
+        // authored value, checked where it is written, not here.
+        if (governmentInherited(record))
+            note.inheritedCultureFields = new Set([
+                ...(note.inheritedCultureFields ?? []),
+                "government",
+            ]);
         if (hierarchyProblems)
             note.reportedCultureParents = new Set(
                 hierarchyProblems

package/engine/content-render.mjs

@@ -40,11 +40,11 @@
  *
  * A note reaches {@link Renderer#render} with its index-dependent constructs
  * already resolved by {@link module:engine/content-expand.expandContent}.
+ * Valid authored page breaks are omitted before these stages.
+ *
  * {@link Renderer#prepare} then writes the constructs markdown-it has no
  * syntax for as HTML between blank lines, in this order:
  *
- * Valid authored page breaks are omitted before these stages.
- *
  * 1. **Marked text** — a run's language, face and mapping, from the
  *    configuration's script notes.
  * 2. **Captioned items** — each figure's wrapper and label. Its number, kind

package/engine/content-tables.mjs

@@ -14,6 +14,7 @@
 import { FENCE_LINE } from "./code-fences.mjs";
 import { PAGE_LIST_LANGUAGE } from "./page-lists.mjs";
 import { appendGeneratedSections } from "./generated-sections.mjs";
+import { insertDeclaredSections } from "./declared-sections.mjs";
 import { insertLexicalSections } from "./lexical-sections.mjs";
 
 /**
@@ -129,8 +130,8 @@ export function expandContentTables(markdown, { source = "", sqlTables, pageList
                 source,
                 directive: block.join("\n"),
                 reason: failure,
-                line: i,
-                column: indent.length + 1,
+                line: prepared?.line ?? i,
+                column: prepared?.column ?? indent.length + 1,
             });
             block.forEach((value, offset) => emit(value, i + offset));
             i = close;
@@ -149,11 +150,17 @@ export function expandContentTables(markdown, { source = "", sqlTables, pageList
         if (close + 1 < lines.length && lines[close + 1].trim()) emit("", i, true);
         i = close;
     }
+    const declared = insertDeclaredSections(out.join("\n"), sqlTables?.declared, {
+        authored,
+        lineMap,
+        generatedFrom,
+        syntax: sqlTables?.syntax,
+    });
     return {
-        ...insertLexicalSections(out.join("\n"), sqlTables?.lexical, {
+        ...insertLexicalSections(declared.markdown, sqlTables?.lexical, {
             authored,
-            lineMap,
-            generatedFrom,
+            lineMap: declared.lineMap,
+            generatedFrom: declared.generatedFrom,
             syntax: sqlTables?.syntax,
         }),
         errors,

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-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)
     );
 }
 

package/engine/language-terms.mjs

@@ -152,8 +152,12 @@ export const JOIN_MEETINGS = Object.freeze(["C+C", "V+C", "V+V"]);
  */
 export const JOIN_RULES = Object.freeze(["merge", "insert", "drop", "double"]);
 
-/** What a written mark says of its letter. */
-export const MARK_KINDS = Object.freeze(["stress", "length", "apart"]);
+/**
+ * What a written mark says of its letter: `stress` falls on it, `length` holds
+ * it longer, `apart` says it apart from its neighbour, and `quality` changes
+ * which vowel is said.
+ */
+export const MARK_KINDS = Object.freeze(["stress", "length", "apart", "quality"]);
 
 /** How many of a mark a word may carry: `one` at most, or `any` number. */
 export const MARK_LIMITS = Object.freeze(["one", "any"]);
@@ -320,13 +324,6 @@ export const SCOPE_FIELDS = Object.freeze([
         entries: Object.freeze({ kind: "address", shape: "an Address" }),
         describe: "These notes themselves.",
     }),
-    Object.freeze({
-        name: "paths",
-        kind: "list",
-        shape: "a list of content paths",
-        entries: Object.freeze({ kind: "string", shape: "a path such as `Regions/Aelwyth/`" }),
-        describe: "Every note whose file sits below one of these paths of the content tree.",
-    }),
     Object.freeze({
         name: "types",
         kind: "list",
@@ -1926,7 +1923,7 @@ export const LANGUAGE_DATA_FIELDS = Object.freeze([
     Object.freeze({
         name: "scope",
         kind: "map",
-        shape: "a map — `{ folders?, cultures?, lore?, parents?, addresses?, paths?, types?, skip? }`",
+        shape: "a map — `{ folders?, cultures?, lore?, parents?, addresses?, types?, skip? }`",
         fields: SCOPE_FIELDS,
         describe: "The notes the register covers. A language skill note only.",
     }),

package/engine/map-dot.mjs

@@ -131,6 +131,26 @@ export const STYLE = Object.freeze({
         penwidth: 2.0,
         extraStyle: "rounded",
     },
+    district: {
+        shape: "box",
+        fill: "#C5E1A5",
+        border: DEFAULT_BORDER,
+        fontsize: 9,
+        width: 0.8,
+        height: 0.4,
+        penwidth: 1.0,
+        extraStyle: "rounded,dashed",
+    },
+    route: {
+        shape: "parallelogram",
+        fill: "#FFE082",
+        border: DEFAULT_BORDER,
+        fontsize: 9,
+        width: 0.9,
+        height: 0.4,
+        penwidth: 1.0,
+        extraStyle: "",
+    },
     settlement: {
         shape: "ellipse",
         fill: "#A5D6A7",
@@ -187,10 +207,12 @@ export const STYLE = Object.freeze({
 const LEGEND = Object.freeze([
     ["world", "the root note"],
     ["region", "continent, region, sub-region"],
+    ["district", "quarter, ward, shire"],
     ["settlement", "city, town, village"],
     ["site", "ruin, landmark, dungeon, wonder"],
     ["feature", "river, mountain range, sea"],
     ["structure", "a single building"],
+    ["route", "road, pass, sea lane"],
     ["polity", "affiliation, dashed edge to its region"],
 ]);