@heroiclands/package-build 25.5.5 → 25.6.1

package/engine/settlement-terms.mjs

@@ -0,0 +1,118 @@
+/*
+ * 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
+ */
+
+/** Dependency-free settlement row declarations. @module */
+/** The generated heading. */
+export const SETTLEMENTS_HEADING = "Settlements";
+
+/** Rendered columns, in their fixed order; Held by and For appear when a row states them. */
+export const SETTLEMENT_COLUMNS = Object.freeze([
+    Object.freeze({ name: "Name", required: true }),
+    Object.freeze({ name: "Market", required: true }),
+    Object.freeze({ name: "People", required: true }),
+    Object.freeze({ name: "Held by", required: false }),
+    Object.freeze({ name: "For", required: false }),
+]);
+
+/** The closed row fields; existing subjects use native Addresses. */
+export const SETTLEMENT_ROW_FIELDS = Object.freeze(
+    [
+        {
+            name: "place",
+            kind: "address",
+            shape: "a place Address",
+            describe: "The existing settlement note; exclusive with name.",
+        },
+        {
+            name: "name",
+            kind: "string",
+            shape: "plain text",
+            describe: "A settlement without a note; exclusive with place.",
+        },
+        {
+            name: "market",
+            kind: "number",
+            required: true,
+            shape: "a market class, 1 to 6",
+            describe: "What trade the settlement supports.",
+        },
+        {
+            name: "population",
+            kind: "number",
+            required: true,
+            shape: "a positive whole number",
+            describe: "How many people live here.",
+        },
+        {
+            name: "heldBy",
+            kind: "address",
+            shape: "an affiliation or being Address",
+            describe:
+                "What holds the settlement's land, where its culture holds land; what the holder is says how it is held.",
+        },
+        {
+            name: "for",
+            kind: "string",
+            shape: "plain text",
+            describe: "Optional reason the settlement exists.",
+        },
+    ].map(Object.freeze),
+);
+
+/** The place vocabulary's single settlement declaration. */
+export const SETTLEMENTS_FIELD = Object.freeze({
+    name: "settlements",
+    kind: "map",
+    shape: "{ rows, tail }",
+    fields: Object.freeze([
+        {
+            name: "rows",
+            kind: "list",
+            required: true,
+            shape: "a list of settlement rows",
+            entries: { kind: "map", shape: "a settlement row", fields: SETTLEMENT_ROW_FIELDS },
+            describe: "One row per settlement.",
+        },
+        {
+            name: "tail",
+            kind: "string",
+            required: true,
+            shape: "a nonempty sentence",
+            describe: "What the table leaves out.",
+        },
+    ]),
+    describe:
+        "A region's settlement rows and the sentence stating what they leave out; the table is generated from this declaration.",
+});
+
+/** Every semantic finding, named once for the reference and its guards. */
+export const SETTLEMENT_TABLE_RULES = Object.freeze(
+    [
+        [
+            "body settlements table",
+            "A body table under Settlements is refused; declare data.settlements.",
+        ],
+        ["settlements shape", "A region declares rows and tail, with one name or place per row."],
+        ["unresolved settlement reference", "A place or heldBy Address does not resolve."],
+        ["market class", "A row's market is not an integer class from 1 to 6."],
+        ["people figure", "A row's population is not a positive whole number."],
+        ["not a holder", "A heldBy Address names neither an affiliation nor a being."],
+        ["not a settlement", "A place Address names a subject that is not a place."],
+        ["figure disagrees", "A linked population differs from its note, or the note states none."],
+        ["market disagrees", "A linked market differs from its note, or the note states none."],
+        ["unlinked settlement", "A plain name has an existing settlement note in this region."],
+        ["missing row", "A covered settlement note has no row."],
+        ["duplicate settlement", "A settlement has another row here or in another region."],
+        ["no tail", "The declaration has no sentence stating what it leaves out."],
+    ].map(([name, describe]) => Object.freeze({ name, describe })),
+);

package/engine/site-build.mjs

@@ -275,11 +275,9 @@ export function collectContentPages(contentBase, ctx) {
             // not use it: a note is addressed as `type/shortcode` wherever it
             // is filed.
             tld: rel.split(path.sep)[0],
-            // Location below the content root, POSIX-separated — what a
-            // generated table reads as `file.path` and scopes on with `FROM`.
+            // Location below the content root, POSIX-separated.
             relPath: rel.split(path.sep).join("/"),
-            // The immediate source subfolder — what a content table reads as
-            // `file.folder`, and the page's `kbfolder`.
+            // The immediate source subfolder — the page's `kbfolder`.
             folder: path.basename(path.dirname(file)),
             // Every page is addressed by `(type, shortcode)` at the package
             // root, which takes no content mount.

package/engine/sql-tables.mjs

@@ -217,6 +217,59 @@ export function findSqlBlocks(markdown) {
     return blocks;
 }
 
+/**
+ * Overwrite string literals and comments with spaces, keeping every offset and
+ * newline, so a search of what remains reads only identifiers and operators.
+ *
+ * @param {string} sql - A query.
+ * @returns {string} The query, the same length.
+ */
+function maskLiterals(sql) {
+    const blank = (text) => text.replace(/[^\n]/g, " ");
+    return sql.replace(/'(?:[^']|'')*'|--[^\n]*|\/\*[\s\S]*?\*\//g, blank);
+}
+
+/**
+ * Where a query reads the `file` block of the index record: `file.path`,
+ * `file.folder` or `file.name`, bare or qualified by a relation or its alias.
+ * A note is selected by property, tag or address, so a query that reaches for
+ * the file it was written in is refused. A field of a note's own data that is
+ * named `file` is not the block and is left alone.
+ *
+ * @param {string} sql - One fence's query.
+ * @returns {{line: number, column: number, text: string}|undefined} The first
+ *   reference, its 0-based line within the query and 1-based column, or
+ *   nothing where the query makes none.
+ */
+export function findFileReference(sql) {
+    const masked = maskLiterals(String(sql ?? ""));
+    const qualifiers = new Set();
+    for (const [, relation, alias] of masked.matchAll(
+        /\b(?:from|join)\s+([\w."]+)(?:\s+(?:as\s+)?([A-Za-z_]\w*))?/gi,
+    )) {
+        qualifiers.add(relation.split(".").at(-1).replaceAll('"', ""));
+        if (
+            alias &&
+            !/^(where|group|order|limit|join|inner|left|right|full|cross|on|union|having|window|qualify|using|natural)$/i.test(
+                alias,
+            )
+        )
+            qualifiers.add(alias);
+    }
+    const reference = /(?<![\w$"])(?:(\w+|"\w+")\s*\.\s*)?"?file"?\s*\.\s*"?(path|folder|name)\b/gi;
+    for (const match of masked.matchAll(reference)) {
+        const qualifier = match[1]?.replaceAll('"', "");
+        if (qualifier && !qualifiers.has(qualifier)) continue;
+        const before = masked.slice(0, match.index);
+        return {
+            line: before.split("\n").length - 1,
+            column: match.index - (before.lastIndexOf("\n") + 1) + 1,
+            text: match[0].replace(/\s+/g, ""),
+        };
+    }
+    return undefined;
+}
+
 /** Omit the Foundry export from SQL; the canonical index stays intact.
  * Keep encoding source keys as case-sensitive values in the SQL projection.
  * The canonical index retains its authored mapping object; DuckDB structs
@@ -1371,6 +1424,16 @@ export async function prepareSqlTables(db, sources, { linkable, records, pageLan
         for (const [ordinal, block] of blocks.entries()) {
             try {
                 if (block.problems.length) throw new Error(block.problems.join("; "));
+                const reference = findFileReference(block.query);
+                if (reference) {
+                    forNote.push({
+                        reason: `\`${reference.text}\` is not available to a query; a query selects notes by property, tag or address`,
+                        line: block.line + 1 + reference.line,
+                        column: reference.column,
+                        allowEmpty: block.allowEmpty,
+                    });
+                    continue;
+                }
                 const result = await runSqlQuery(reader, block.query);
                 const options = {
                     linkable,
@@ -1558,11 +1621,13 @@ export async function prepareInlineSqlExpressions(db, sources) {
  * @param {Map<string, Map<string, string>>} [opts.derived] - The derived
  *   lists, from an earlier call over the same records, which are not derived
  *   again.
+ * @param {Map<string,{raw?:string}>} [opts.parsed] - Captured source locators.
  * @param {object[]} [opts.all=records] - Complete records for lexical lineage
  *   traversal through providers outside the surface's audience.
  * @returns {Promise<{sections: Map<string, string>, views: Set<string>,
  *   derived: Map<string, Map<string, string>>,
- *   lexical: Map<string, import("./lexical-sections.mjs").LexicalSection[]>}>} Note file to its sections,
+ *   lexical: Map<string, import("./lexical-sections.mjs").LexicalSection[]>,
+ *   declared: Map<string, Array<{slug:string,heading:string,markdown:string}>>}>} Note file to its sections,
  *   joined in order; the files whose sections hold an event view's fence; and
  *   the derived lists alone.
  */
@@ -1570,7 +1635,7 @@ export async function generatedSectionsFor(
     db,
     records,
     contentBase,
-    { only, foreignIndex, config, derived: given, all = records } = {},
+    { only, foreignIndex, config, derived: given, all = records, parsed } = {},
 ) {
     const notes = records.filter((record) => isNoteRecord(record));
     const fileOf = (record) => noteFile(contentBase, record);
@@ -1583,11 +1648,27 @@ export async function generatedSectionsFor(
             foreignIndex,
             config,
             only,
+            all,
+            rawOf: (file) => parsed?.get(file)?.raw,
         });
     const views = db ? await eventViewSections(db, notes, fileOf, only) : new Map();
     const sections = new Map();
-    for (const file of new Set([...derived.keys(), ...views.keys()]))
-        sections.set(file, joinSections([derived.get(file), views.get(file)]));
+    const declared = new Map();
+    for (const file of new Set([...derived.keys(), ...views.keys()])) {
+        const lists = new Map(derived.get(file));
+        const settlements = lists.get("settlements");
+        if (settlements)
+            declared.set(file, [
+                {
+                    slug: "settlements",
+                    heading: "Settlements",
+                    markdown: settlements.replace(/^# Settlements \{#settlements\}\s*\n/, ""),
+                },
+            ]);
+        lists.delete("settlements");
+        const text = joinSections([lists, views.get(file)]);
+        if (text) sections.set(file, text);
+    }
     // Automatic sections follow their source's audience even in a Foundry
     // corpus containing both public and private packs. Explicit SQL keeps
     // the database audience the caller requested.
@@ -1607,7 +1688,7 @@ export async function generatedSectionsFor(
         if (owners.has(key) && (only === undefined || fileOf(note) === only))
             lexical.set(fileOf(note), owners.get(key));
     }
-    return { sections, views: new Set(views.keys()), derived, lexical };
+    return { sections, views: new Set(views.keys()), derived, lexical, declared };
 }
 
 /**
@@ -1654,11 +1735,16 @@ export function joinGeneratedSections(generated, sources, parsed) {
  * empty set carrying them.
  *
  * @param {Map<string, object[]>} prepared - From {@link prepareSqlTables}.
- * @param {{sections: Map<string, string>, lexical?: Map<string, import("./lexical-sections.mjs").LexicalSection[]>}} generated - From
+ * @param {{sections: Map<string, string>, lexical?: Map<string, import("./lexical-sections.mjs").LexicalSection[]>, declared?: Map<string, Array<{slug:string,heading:string,markdown:string}>>}} generated - From
  *   {@link generatedSectionsFor}.
  * @returns {void}
  */
 export function attachGeneratedSections(prepared, generated) {
+    for (const [absPath, sections] of generated.declared ?? []) {
+        let results = prepared.get(absPath);
+        if (!results) prepared.set(absPath, (results = []));
+        results.declared = sections;
+    }
     for (const [absPath, text] of generated.sections) {
         let results = prepared.get(absPath);
         if (!results) prepared.set(absPath, (results = []));
@@ -1881,11 +1967,18 @@ export async function prepareTreeSqlTables(
         }
     }
     const derivedOnly = await generatedSectionsFor(undefined, indexRecords, contentBase, {
+        parsed,
         foreignIndex: foreign,
         config,
         all: allRecords,
     });
-    if (!sources.length && !hasEvents && !derivedOnly.sections.size && !derivedOnly.lexical.size)
+    if (
+        !sources.length &&
+        !hasEvents &&
+        !derivedOnly.sections.size &&
+        !derivedOnly.lexical.size &&
+        !derivedOnly.declared.size
+    )
         return undefined;
 
     // A page list is a filter over the records, so it needs no database. A tree
@@ -1940,6 +2033,7 @@ export async function prepareTreeSqlTables(
         }));
     try {
         const generated = await generatedSectionsFor(db, indexRecords, contentBase, {
+            parsed,
             derived: derivedOnly.derived,
             all: allRecords,
         });

package/engine/standing-terms.mjs

@@ -35,8 +35,9 @@ export const STANDING_BODY_TYPES = Object.freeze(["affiliation"]);
  * The keys one standing carries, as inner-key declarations.
  *
  * `rank` is the level on the body's own `governance.ranks` ladder, and every
- * membership states one. `office` is a key of its `governance.offices` map, and
- * is stated only where the being holds a post. `societies` names the societies
+ * membership states one. `office` is a key of its `governance.offices` map, or
+ * a list of them where the being holds several posts in that body, and is
+ * stated only where the being holds a post. `societies` names the societies
  * the membership is held in, as a list because a membership can span several.
  *
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
@@ -53,9 +54,12 @@ export const STANDING_FIELDS = Object.freeze([
     }),
     Object.freeze({
         name: "office",
-        kind: "string",
-        shape: "a post from that body's `governance.offices`",
-        describe: "A post the body names in its `governance.offices`, where one is held.",
+        kind: "string-or-list",
+        shape: "a post from that body's `governance.offices`, or a list of them",
+        entries: Object.freeze({ kind: "string", shape: "a post" }),
+        describe:
+            "A post the body names in its `governance.offices`, where one is held, or a list of " +
+            "the posts one being holds in that body.",
     }),
     Object.freeze({
         name: "societies",

package/engine/standings.mjs

@@ -31,7 +31,8 @@
  * **`rank` is a number, not a link.** The body declares `{level, title,
  * description}` for every rung of its `governance.ranks`, so a number indexes
  * into that ladder and the body stays the single source for what its level 5 is
- * called. **`office` is a string**, matched against the keys of the body's
+ * called. **`office` is a string, or a list of them** for one being holding
+ * several posts in one body, each matched against the keys of the body's
  * `governance.offices` map: there are far more offices in a tree than bodies,
  * most of them held by one body alone, and an Address would make writing the
  * fact wait on authoring a page about the post.
@@ -55,7 +56,7 @@ import { acceptsType, isAddressTuple, parseAddress, renderAddress } from "./addr
 import { AddressEntries } from "./address-values.mjs";
 import { slugify } from "./content-slug.mjs";
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
-import { fitsKind } from "./data-keys.mjs";
+import { fitsKind, pathLabel } from "./data-keys.mjs";
 import { STANDING_BODY_TYPES, STANDING_FIELDS, STANDING_KEYS } from "./standing-terms.mjs";
 
 export { STANDING_BODY_TYPES, STANDING_FIELDS, STANDING_KEYS };
@@ -221,12 +222,45 @@ export function standingsDigest(fm) {
     };
 }
 
+/**
+ * The posts one standing names, as written: one post, or each post of a list.
+ *
+ * Every entry is kept, blank or not text included, so the check can locate
+ * each one; a reader of the posts themselves takes {@link standingOffices}.
+ *
+ * @param {unknown} office - A standing's authored `office`.
+ * @returns {Array<{value: unknown, at: Array<number>}>} Each post with its
+ *   position below `office` — `[]` for the single form, `[i]` for a list entry.
+ */
+function writtenOffices(office) {
+    if (office === undefined || office === null) return [];
+    if (Array.isArray(office)) return office.map((value, i) => ({ value, at: [i] }));
+    return [{ value: office, at: [] }];
+}
+
+/**
+ * The posts a standing holds, trimmed, in the order written.
+ *
+ * `office` is one post or a list of them, and every reader — the line on the
+ * being's page, the SoHL item, the derived holders of an office — wants the
+ * same list from both.
+ *
+ * @param {object} [standing] - `{rank, office}`, either or both absent.
+ * @returns {string[]} The posts, blank and non-text entries left out.
+ */
+export function standingOffices(standing) {
+    return writtenOffices(standing?.office)
+        .map(({ value }) => (typeof value === "string" ? value.trim() : ""))
+        .filter(Boolean);
+}
+
 /**
  * What a standing says before the body that confers it — `War Chief, Hárár
  * (5), of ` — or `""` where no standing is held.
  *
  * The office leads, because it is the more particular of the two: a reader
- * meeting "War Chief" has been told the rung as well. The rung follows as its
+ * meeting "War Chief" has been told the rung as well. Several posts in one
+ * body lead in the order written, `Treasurer, Chancellor, …`. The rung follows as its
  * title with its level in parentheses, read from the body's own ladder; where
  * the ladder names no rung at that level, or none is available, it reads as
  * `Rank 5` and the number is not repeated. The body closes the phrase, which is
@@ -241,9 +275,7 @@ export function standingsDigest(fm) {
  * @returns {string} The words before the body's name, ending `of `.
  */
 export function standingLead(standing, digest) {
-    const parts = [];
-    if (typeof standing?.office === "string" && standing.office.trim())
-        parts.push(standing.office.trim());
+    const parts = [...standingOffices(standing)];
     const rank = standing?.rank;
     const level = typeof rank === "number" || typeof rank === "string" ? Number(rank) : NaN;
     if (rank !== "" && Number.isFinite(level)) {
@@ -264,7 +296,7 @@ export function standingLead(standing, digest) {
  * 3. the entry states a standing at all — what a stated standing holds is the
  *    inner-key check's, read from {@link STANDING_FIELDS};
  * 4. a `rank` is a level the named body's `governance.ranks` declares;
- * 5. an `office` is a key of that body's `governance.offices`.
+ * 5. each post an `office` names is a key of that body's `governance.offices`.
  *
  * Both of the last two are read from the named body's own frontmatter as the
  * lint runs, so a rung or a post that does not exist fails on every being pointing
@@ -474,39 +506,59 @@ function rankFindings(note, standing, body, path, resolved) {
     ];
 }
 
-/** Whether an `office` is a post the named body names. */
+/**
+ * Whether each post an `office` names is one the named body names.
+ *
+ * `office` is one post or a list of them, and each is checked on its own and
+ * located at its own value, so a list naming one unknown post among several is
+ * one finding at that post.
+ */
 function officeFindings(note, standing, body, path, resolved) {
-    // Absent is a membership with no post; a value that is not text is the
-    // inner-key check's finding.
-    if (typeof standing.office !== "string") return [];
-    const at = () => position(note, [...path, "office"]);
-    if (!standing.office.trim())
-        return [
-            {
+    const roster = resolved.fm ? officeRoster(resolved.fm.data?.governance?.offices) : undefined;
+    const findings = [];
+    for (const { value, at: below } of writtenOffices(standing.office)) {
+        if (typeof value !== "string") {
+            // A list entry that is not text is the inner-key check's finding,
+            // read from the declaration's `entries`. The single form is one
+            // post too, and the inner-key check reads only a list's entries.
+            if (!below.length)
+                findings.push({
+                    ...position(note, [...path, "office"]),
+                    message:
+                        `\`${pathLabel(["data", "affiliations", ...path.slice(2), "office"])}\` ` +
+                        `should be ${STANDING_FIELDS.find((f) => f.name === "office").shape}, ` +
+                        `but reads ${JSON.stringify(value)}`,
+                });
+            continue;
+        }
+        const at = () => position(note, [...path, "office", ...below]);
+        if (!value.trim()) {
+            findings.push({
                 ...at(),
                 message:
                     `\`data.affiliations\` entry for ${body}: \`office\` must name a post from its ` +
-                    `\`governance.offices\`, but reads ${JSON.stringify(standing.office)}`,
-            },
-        ];
-    if (!resolved.fm) return [];
-    const roster = officeRoster(resolved.fm.data?.governance?.offices);
-    if (roster.has(standing.office)) return [];
-    if (!roster.size)
-        return [
-            {
+                    `\`governance.offices\`, but reads ${JSON.stringify(value)}`,
+            });
+            continue;
+        }
+        if (!roster || roster.has(value)) continue;
+        if (!roster.size) {
+            findings.push({
                 ...at(),
                 message:
                     `\`data.affiliations\` entry for ${body} names an office, and that body ` +
                     `${resolved.address} declares no \`data.governance.offices\` to hold one`,
-            },
-        ];
-    return [
-        {
+            });
+            // One finding says the body holds no posts; each further post
+            // would repeat it.
+            break;
+        }
+        findings.push({
             ...at(),
             message:
-                `\`data.affiliations\` entry for ${body}: office ${JSON.stringify(standing.office)} is not ` +
+                `\`data.affiliations\` entry for ${body}: office ${JSON.stringify(value)} is not ` +
                 `an office ${resolved.address} names; it holds ${[...roster.keys()].join(", ")}`,
-        },
-    ];
+        });
+    }
+    return findings;
 }

package/engine/unique-items.mjs

@@ -0,0 +1,85 @@
+/*
+ * 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
+ */
+
+/**
+ * **A one-of-a-kind item is tied to the places and beings involved.**
+ *
+ * `data.unique: true` on a gear note marks an item there is only one of — a
+ * named hammer, a crown, a sword in a tomb. Where it lies and who claims it are
+ * prose, because possession changes with play and ownership is a claim that
+ * can be disputed; so the note's own links are what tie it to the world, and a
+ * unique item whose note links no place and no being is a finding.
+ *
+ * A link counts wherever the note writes it: a wikilink in its body, or a
+ * `made` or `lost` event Address naming a place's or a being's event.
+ *
+ * @module
+ */
+
+import { isAddressTuple, parseAddress } from "./address.mjs";
+import { matchAllOutsideCode } from "./code-fences.mjs";
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+import { parseWikilink, WIKILINK } from "./wikilink-syntax.mjs";
+
+/** The note types a unique item's links must reach at least one of. */
+export const UNIQUE_ITEM_LINK_TYPES = Object.freeze(["place", "being"]);
+
+/**
+ * The note type one written target names, or `""` where it is no Address.
+ *
+ * @param {unknown} target - A wikilink target or an authored Address.
+ * @param {object} [index] - The lint's address index.
+ * @returns {string} The type.
+ */
+function typeOf(target, index) {
+    if (isAddressTuple(target)) return target.type;
+    // An event Address arrives decoded as a link to its note and anchor.
+    if (isAddressTuple(target?.target)) return target.target.type;
+    const tuple = parseAddress(String(target ?? "").split("#")[0], {
+        package: index?.contentPackage,
+        system: "note",
+        types: index?.types,
+        packages: index?.packages,
+    });
+    return tuple.reason ? "" : String(tuple.type ?? "");
+}
+
+/**
+ * Report a unique item whose note links no place or being.
+ *
+ * @param {object} note - The note: `file`, `raw`, `body` and parsed `fm`.
+ * @param {{index?: object}} [options] - The lint's options.
+ * @returns {object[]} The finding, located at `unique`, or none.
+ */
+export function checkUniqueItem(note, { index } = {}) {
+    const data = note.fm?.data;
+    if (data?.unique !== true && data?.unique !== "true") return [];
+    const targets = [
+        data.made,
+        data.lost,
+        ...matchAllOutsideCode(note.body ?? "", new RegExp(WIKILINK.source, "g")).map(
+            ([, inner]) => parseWikilink(inner).target,
+        ),
+    ].filter(Boolean);
+    if (targets.some((target) => UNIQUE_ITEM_LINK_TYPES.includes(typeOf(target, index)))) return [];
+    return [
+        {
+            file: note.file,
+            ...positionOfFrontmatterPath(note.raw ?? "", ["data", "unique"], { key: true }),
+            severity: "error",
+            message:
+                "a unique item links no place or being; link where it lies or who " +
+                "holds or claims it in the note's prose",
+        },
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "25.5.5",
+    "version": "25.6.1",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package \u2014 content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",
@@ -157,7 +157,7 @@
         "eslint-plugin-yml": "^3.8.1",
         "fflate": "^0.8.3",
         "flesch": "^2.0.1",
-        "glob": "^14.0.0",
+        "glob": "^14.0.3",
         "handlebars": "^4.7.10",
         "highlight.js": "^11.12.0",
         "ignore": "^7.0.12",
@@ -168,7 +168,7 @@
         "markdown-it": "^15.0.0",
         "markdown-it-deflist": "^4.0.0",
         "markdown-it-footnote": "^4.0.0",
-        "minimatch": "^11.0.0",
+        "minimatch": "^11.0.3",
         "pagefind": "^1.5.2",
         "prettier": "^3.9.6",
         "remark-frontmatter": "^5.0.0",
@@ -243,5 +243,10 @@
         "sohl",
         "song-of-heroic-lands"
     ],
-    "homepage": "https://github.com/HeroicLands/package-build#documentation"
+    "homepage": "https://github.com/HeroicLands/package-build#documentation",
+    "overrides": {
+        "minimatch": "$minimatch",
+        "katex": "0.18.2",
+        "re2js": "2.8.7"
+    }
 }

package/site-theme/data/banner-kinds.yaml

@@ -64,8 +64,10 @@ kinds:
     mysticalability: mystical-abilities
     place:
         celestial: default
+        district: default
         feature: default
         region: region
+        route: default
         settlement: settlement
         site: default
         structure: default