@heroiclands/package-build 22.4.6 → 22.4.7

package/engine/holdings.mjs

@@ -0,0 +1,391 @@
+/*
+ * 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
+ */
+
+/**
+ * What lies within a place, who holds it, and what an affiliation holds.
+ *
+ * Two keys the notes already carry answer all three. A place's `data.parents`
+ * is geography — the places it sits within — and an affiliation's
+ * `data.domains` is tenure — the places it holds. Read across the whole
+ * corpus and inverted, they give each page the lists a reader wants:
+ * `contains` and `held_by` on a place, `holdings` on an affiliation, each
+ * shaped like an entry of `related` and absent where empty.
+ *
+ * **`domains` names what an affiliation holds directly**, and is never
+ * expanded. A polity whose `domains` names a region holds the region; the
+ * settlements within it are reachable from the region's `contains`, and
+ * repeating them in `holdings` would make every list say the same thing at
+ * every level. Tenure below a lord runs through `affiliation.parents` — a
+ * house of its earl, an earl of the crown — and geography through
+ * `place.parents`, so a subinfeudated manor sits in one region by the first
+ * and under a lord of another polity by the second, and both pages say so.
+ *
+ * **A dependency's places and affiliations take part.** A fetched index entry
+ * carries the `parents` and `domains` its record stated, so a place another
+ * package publishes is listed within a local region, and a house another
+ * package publishes is named on the local manor it holds.
+ *
+ * **A place's tenure is checked.** A settlement, a site or a structure that no
+ * affiliation's `domains` names is land nobody holds — a gap in tenure the
+ * lint reports as a warning at the note's `type:` line. A region is held
+ * through its polity's `domains` and a feature by nobody, so both are exempt.
+ *
+ * @module
+ */
+
+import { positionInFrontmatter } from "./diagnostics.mjs";
+
+/**
+ * The keys this module writes, and which a note cannot author: `contains`
+ * and `held_by` on a place, `holdings` on an affiliation.
+ *
+ * @type {readonly string[]}
+ */
+export const HOLDINGS_KEYS = Object.freeze(["contains", "held_by", "holdings"]);
+
+/**
+ * The place subTypes tenure is checked on. A region is held through its
+ * polity's `domains`, a world by nobody, a feature by nobody — a river has no
+ * lord — so the rest are the kinds of place a body holds directly.
+ *
+ * @type {readonly string[]}
+ */
+export const HELD_SUBTYPES = Object.freeze(["settlement", "site", "structure"]);
+
+/**
+ * One entry of a holdings list — a page a reader is pointed at.
+ *
+ * @typedef {object} HoldingsEntry
+ * @property {string} title   The page's published title.
+ * @property {string} url     `<base><slug>/` — the page's address as every
+ *                            href this build renders composes it.
+ * @property {string} type    The note's `type` — `place` or `affiliation`.
+ * @property {string} [subType] The note's `subType`, where it declares one.
+ */
+
+/**
+ * One place or affiliation, as the derivation reads it — a local page or a
+ * fetched index entry through one shape.
+ *
+ * @typedef {object} HoldingsNode
+ * @property {string} shortcode Lower case.
+ * @property {"place"|"affiliation"} type
+ * @property {string} [subType]
+ * @property {string} title     The page's published title.
+ * @property {string} [url]     The page's URL; absent where the package
+ *                              publishes no page for it.
+ * @property {string[]} parents What a place sits within, as written.
+ * @property {string[]} domains What an affiliation holds, as written.
+ */
+
+/**
+ * The lists one page carries. Every key is optional, and a key present holds
+ * at least one entry.
+ *
+ * @typedef {object} Holdings
+ * @property {HoldingsEntry[]} [contains] Places whose `parents` name this one.
+ * @property {HoldingsEntry[]} [held_by]  Affiliations whose `domains` name this one.
+ * @property {HoldingsEntry[]} [holdings] Places this affiliation's `domains` name.
+ */
+
+/**
+ * The shortcode a `parents` or `domains` entry names, lower case.
+ *
+ * An entry is written as a bare shortcode, as an address, or as a wikilink
+ * carrying either; the shortcode is the last segment of the address in every
+ * case, because a segment carries no separator.
+ *
+ * @param {unknown} value - One entry.
+ * @returns {string} Its shortcode, or `""` for an entry that names nothing.
+ */
+function namedShortcode(value) {
+    const text = String(value ?? "")
+        .trim()
+        .replace(/^\[\[/, "")
+        .replace(/\]\]$/, "")
+        .split("|")[0]
+        .split("#")[0]
+        .trim();
+    return text.split("-").pop()?.toLowerCase() ?? "";
+}
+
+/**
+ * A `parents` or `domains` value as the shortcodes it names, in order,
+ * empties dropped and repeats collapsed.
+ *
+ * @param {unknown} value - The authored value — a list, or a lone entry.
+ * @returns {string[]} The shortcodes.
+ */
+function shortcodesOf(value) {
+    const list =
+        Array.isArray(value) ? value
+        : value ? [value]
+        : [];
+    return [...new Set(list.map(namedShortcode).filter(Boolean))];
+}
+
+/**
+ * A stable order for `contains` and `holdings`: by subType, then title. An
+ * entry with no subType sorts first.
+ *
+ * @param {HoldingsEntry} a
+ * @param {HoldingsEntry} b
+ * @returns {number}
+ */
+function bySubTypeThenTitle(a, b) {
+    return (
+        (a.subType ?? "").localeCompare(b.subType ?? "", "en") ||
+        a.title.localeCompare(b.title, "en")
+    );
+}
+
+/**
+ * A stable order for `held_by`: by title.
+ *
+ * @param {HoldingsEntry} a
+ * @param {HoldingsEntry} b
+ * @returns {number}
+ */
+function byTitle(a, b) {
+    return a.title.localeCompare(b.title, "en");
+}
+
+/**
+ * The entry a node is listed as.
+ *
+ * @param {HoldingsNode & {url: string}} node - A node with a page.
+ * @returns {HoldingsEntry} Its entry.
+ */
+function entryOf(node) {
+    return {
+        title: node.title,
+        url: node.url,
+        type: node.type,
+        ...(node.subType === undefined ? {} : { subType: node.subType }),
+    };
+}
+
+/**
+ * Read a local note into a node, or `null` for a note that takes no part.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {object} page - The page it publishes as.
+ * @param {string} page.title - Its published title.
+ * @param {string} page.url - Its URL.
+ * @returns {HoldingsNode|null} The node, or `null` for a note that is neither
+ *   a place nor an affiliation, or that declares no shortcode.
+ */
+export function holdingsNode(fm, { title, url }) {
+    const type = String(fm?.type ?? "");
+    if (type !== "place" && type !== "affiliation") return null;
+    const shortcode = String(fm?.shortcode ?? "").toLowerCase();
+    if (!shortcode) return null;
+    const data = fm.data && typeof fm.data === "object" && !Array.isArray(fm.data) ? fm.data : {};
+    return {
+        shortcode,
+        type,
+        subType: fm.subType == null ? undefined : String(fm.subType),
+        title,
+        url,
+        parents: type === "place" ? shortcodesOf(data.parents) : [],
+        domains: type === "affiliation" ? shortcodesOf(data.domains) : [],
+    };
+}
+
+/**
+ * Read a fetched index's places and affiliations as nodes.
+ *
+ * An entry carries what the producer's record stated — its name, `subType`,
+ * `parents` and `domains` — and its page URL where the package publishes one.
+ *
+ * @param {Map<string, object>|undefined} foreignIndex - As
+ *   {@link module:engine/metadata-index.loadForeignIndexes} returns it.
+ * @returns {HoldingsNode[]} The nodes, in index order.
+ */
+export function foreignHoldingsNodes(foreignIndex) {
+    const out = [];
+    if (!foreignIndex) return out;
+    for (const [canonical, entry] of foreignIndex) {
+        const type = String(entry?.type ?? "");
+        if (type !== "place" && type !== "affiliation") continue;
+        const shortcode = canonical.split("-").pop()?.toLowerCase() ?? "";
+        if (!shortcode) continue;
+        out.push({
+            shortcode,
+            type,
+            subType: entry.subType == null ? undefined : String(entry.subType),
+            title: String(entry.name ?? shortcode),
+            url: entry.url,
+            parents: type === "place" ? shortcodesOf(entry.parents) : [],
+            domains: type === "affiliation" ? shortcodesOf(entry.domains) : [],
+        });
+    }
+    return out;
+}
+
+/**
+ * Invert `parents` and `domains` into each page's lists.
+ *
+ * A shortcode is declared once per type: the first node declaring it wins,
+ * so local nodes handed in ahead of fetched ones shadow a dependency's, the
+ * way the link resolver answers. A node with no URL is nobody's entry and
+ * carries no lists of its own, since there is no page to write them on. A
+ * name no node declares is dropped: a `parents` naming nowhere is the map's
+ * finding, a `domains` naming nowhere the reference check's.
+ *
+ * The result holds only pages with at least one entry on at least one list,
+ * and a page's block carries only the keys it has entries for — the theme's
+ * silent-disappear convention, kept at the source.
+ *
+ * @param {Iterable<HoldingsNode|null>} nodes - Every place and affiliation,
+ *   local first. `parents` and `domains` are read as written, so a node
+ *   built by hand may carry them as the note spells them.
+ * @returns {Map<string, Holdings>} URL → the page's lists, sorted.
+ */
+export function holdingsPages(nodes) {
+    /** @type {Map<string, HoldingsNode>} */
+    const places = new Map();
+    /** @type {Map<string, HoldingsNode>} */
+    const affiliations = new Map();
+    for (const node of nodes) {
+        if (!node) continue;
+        const by = node.type === "place" ? places : affiliations;
+        const shortcode = String(node.shortcode ?? "").toLowerCase();
+        if (!shortcode || by.has(shortcode)) continue;
+        // Read through the one reader, so a caller handing in what a note
+        // wrote — an address, a wikilink, a repeat — is read as `holdingsNode`
+        // reads it.
+        by.set(shortcode, {
+            ...node,
+            shortcode,
+            parents: shortcodesOf(node.parents),
+            domains: shortcodesOf(node.domains),
+        });
+    }
+
+    /** @type {Map<string, {contains: HoldingsEntry[], held_by: HoldingsEntry[], holdings: HoldingsEntry[]}>} */
+    const lists = new Map();
+    const on = (url) => {
+        let found = lists.get(url);
+        if (!found) {
+            found = { contains: [], held_by: [], holdings: [] };
+            lists.set(url, found);
+        }
+        return found;
+    };
+    const listed = (node) => node.url !== undefined && node.url !== null && node.url !== "";
+
+    for (const child of places.values()) {
+        if (!listed(child)) continue;
+        for (const shortcode of child.parents) {
+            const parent = places.get(shortcode);
+            if (!parent || !listed(parent) || parent === child) continue;
+            on(parent.url).contains.push(entryOf(/** @type {any} */ (child)));
+        }
+    }
+
+    for (const holder of affiliations.values()) {
+        if (!listed(holder)) continue;
+        for (const shortcode of holder.domains) {
+            const held = places.get(shortcode);
+            if (!held || !listed(held)) continue;
+            on(holder.url).holdings.push(entryOf(/** @type {any} */ (held)));
+            on(held.url).held_by.push(entryOf(/** @type {any} */ (holder)));
+        }
+    }
+
+    const out = new Map();
+    for (const [url, { contains, held_by, holdings }] of lists) {
+        /** @type {Holdings} */
+        const block = {};
+        if (contains.length) block.contains = contains.sort(bySubTypeThenTitle);
+        if (held_by.length) block.held_by = held_by.sort(byTitle);
+        if (holdings.length) block.holdings = holdings.sort(bySubTypeThenTitle);
+        if (Object.keys(block).length) out.set(url, block);
+    }
+    return out;
+}
+
+/* --------------------------------------------------------------------- */
+/*  The lint                                                              */
+/* --------------------------------------------------------------------- */
+
+/**
+ * Every shortcode some affiliation's `domains` names, computed once per link
+ * index. The lint asks the question once per place note, and the answer is a
+ * fact about the whole corpus — local notes and every fetched entry — so it
+ * is read off the index the first time and kept beside it.
+ *
+ * @type {WeakMap<object, Set<string>>}
+ */
+const HELD = new WeakMap();
+
+/**
+ * The shortcodes every affiliation's `domains` names, across the link index.
+ *
+ * @param {object} index - The link index.
+ * @returns {Set<string>} The held shortcodes, lower case.
+ */
+function heldShortcodes(index) {
+    let held = HELD.get(index);
+    if (held) return held;
+    held = new Set();
+    for (const note of index.notes ?? []) {
+        if (String(note.type ?? note.fm?.type ?? "") !== "affiliation") continue;
+        const data = note.fm?.data;
+        const domains = data && typeof data === "object" ? data.domains : undefined;
+        for (const shortcode of shortcodesOf(domains)) held.add(shortcode);
+    }
+    for (const entry of index.foreign?.index?.values?.() ?? []) {
+        if (String(entry?.type ?? "") !== "affiliation") continue;
+        for (const shortcode of shortcodesOf(entry.domains)) held.add(shortcode);
+    }
+    HELD.set(index, held);
+    return held;
+}
+
+/**
+ * Check a place note's tenure: a settlement, a site or a structure that no
+ * affiliation's `domains` names is unheld land, reported as a warning at the
+ * note's `type:` line.
+ *
+ * Declared on the `place` vocabulary as its type-level check, so the lint
+ * runs it beside the field checks with the same index. Without an index the
+ * question cannot be asked and nothing is reported.
+ *
+ * @param {object} note - The note, as the link index hands it over.
+ * @param {object} [opts]
+ * @param {object} [opts.index] - The link index, holding every affiliation.
+ * @returns {object[]} Findings.
+ */
+export function checkHeld(note, { index } = {}) {
+    if (!index) return [];
+    const fm = note.fm ?? {};
+    if (String(fm.type ?? "") !== "place") return [];
+    const subType = String(fm.subType ?? "");
+    if (!HELD_SUBTYPES.includes(subType)) return [];
+    const shortcode = String(fm.shortcode ?? "").toLowerCase();
+    if (!shortcode) return [];
+    if (heldShortcodes(index).has(shortcode)) return [];
+    return [
+        {
+            file: note.file,
+            ...positionInFrontmatter(note.raw ?? "", "type", undefined, { topLevel: true }),
+            severity: "warning",
+            message:
+                `unheld land: no affiliation's \`domains\` names "${shortcode}", so nothing ` +
+                `says who holds this ${subType}; name it in the \`domains\` of the house, ` +
+                `order or polity that does`,
+        },
+    ];
+}

package/engine/index.mjs

@@ -87,6 +87,12 @@ export * as noteVocabulary from "./note-vocabulary.mjs";
 /** What a place is next to and reachable from: the closed sets, and the checks. */
 export * as placeRelations from "./place-relations.mjs";
 
+/** What lies within a place, who holds it, and what an affiliation holds — the page lists, and the tenure check. */
+export * as holdings from "./holdings.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";
+
 /** The places a map is drawn from, read from the content index, and what `parents` says about them. */
 export * as mapPlaces from "./map-places.mjs";
 
@@ -102,6 +108,9 @@ export * as mapGraphviz from "./map-graphviz.mjs";
 /** `content-build map`: the drawings, written under `build/map/`. */
 export * as mapBuild from "./map-build.mjs";
 
+/** The map from each place, drawn for the site and written into its page. */
+export * as siteMaps from "./site-maps.mjs";
+
 /** The closed registry of system ids, and the `none` that stands for no system. */
 export * as systems from "./systems.mjs";
 

package/engine/map-graphviz.mjs

@@ -89,9 +89,19 @@ export function findGraphviz(engine, { env = process.env, fallbacks = KNOWN_DIRE
     return undefined;
 }
 
+/**
+ * What installs GraphViz on the two platforms a contributor is likely to be
+ * on, as the clause every "not installed" message ends with.
+ *
+ * @type {string}
+ */
+export const GRAPHVIZ_INSTALL =
+    "install GraphViz (`brew install graphviz` on macOS, " +
+    "`apt-get install graphviz` on Debian or Ubuntu)";
+
 /**
  * What to say when an engine is not installed: the name, and what installs
- * it on the two platforms a contributor is likely to be on.
+ * it.
  *
  * @param {string} engine - The engine that was wanted.
  * @returns {string} The message.
@@ -99,8 +109,7 @@ export function findGraphviz(engine, { env = process.env, fallbacks = KNOWN_DIRE
 export function graphvizMissingMessage(engine) {
     return (
         `GraphViz's \`${engine}\` is not installed, and \`content-build map\` draws with it; ` +
-        `install GraphViz (\`brew install graphviz\` on macOS, ` +
-        `\`apt-get install graphviz\` on Debian or Ubuntu) and run the command again`
+        `${GRAPHVIZ_INSTALL} and run the command again`
     );
 }
 

package/engine/map-places.mjs

@@ -251,14 +251,44 @@ export function loadMapWorld({ config, contentBase, base, problems }) {
         skipDirectories: config.skipDirectories,
         problems,
     });
-    const world = placesFromRecords(records, { contentBase: tree, base });
-    world.config = config;
     const foreign = loadForeignIndexes(config, [config.contentPackage]);
-    addForeignPlaces(world, foreign.index);
+    const world = mapWorld({
+        records,
+        foreignIndex: foreign.index,
+        contentBase: tree,
+        base,
+        config,
+    });
     world.stale = foreign.stale;
     return world;
 }
 
+/**
+ * The world a map is drawn from, out of records and indexes a caller already
+ * holds: this package's places from its index records, and every
+ * dependency's from the fetched indexes. The site build reads its corpus and
+ * its foreign indexes once for every surface it publishes, and hands them
+ * here rather than walking the tree a second time.
+ *
+ * @param {object} opts
+ * @param {Array<Record<string, any>>} opts.records - Index records, as
+ *   {@link module:engine/content-index.indexRecordsFor} returns them.
+ * @param {Map<string, object>} opts.foreignIndex - The fetched indexes, as
+ *   {@link module:engine/metadata-index.loadForeignIndexes} returns `index`.
+ * @param {string} opts.contentBase - The content root the records were read from.
+ * @param {string} [opts.base] - The site base this package's pages are served
+ *   under. Absent, no local place carries a URL.
+ * @param {object} opts.config - The resolved configuration.
+ * @returns {MapWorld} The world, with nothing stale: the caller has already
+ *   judged its indexes usable.
+ */
+export function mapWorld({ records, foreignIndex, contentBase, base, config }) {
+    const world = placesFromRecords(records, { contentBase, base });
+    world.config = config;
+    addForeignPlaces(world, foreignIndex);
+    return world;
+}
+
 /* --------------------------------------------------------------------- */
 /*  Containment                                                           */
 /* --------------------------------------------------------------------- */

package/engine/market-class.mjs

@@ -0,0 +1,178 @@
+/*
+ * 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
+ */
+
+/**
+ * What trade a settlement supports — a place note's `data.market`.
+ *
+ * `data.population` says how many people a settlement holds, which is not the
+ * same question as what a traveller can buy there. Two settlements of eight
+ * hundred are a different proposition when one has a weekly market and the
+ * other a chartered fair with a moneylender, and `market` is where a note says
+ * which.
+ *
+ * **The scale is six steps and is stated once, here.** The lint refuses a
+ * value against it, the vocabulary's `describe` reads its ends, and
+ * `docs/content-format.md` states it as a table the suite compares against
+ * this list. A second copy of the scale is one more list free to disagree
+ * about what a `4` buys.
+ *
+ * **A class is a step, not a measurement.** The numbers order the steps and
+ * nothing more: a `5` is not a market two fifths larger than a `3`, it is a
+ * city rather than a town. So a value off the scale is refused rather than
+ * clamped — a reader of the scale has to be able to trust that every number
+ * means the same thing wherever it appears.
+ *
+ * **The key is meaningful on a settlement**, and no subType condition is
+ * checked. `population` states none either: which places a key says something
+ * about is the author's judgement, and the `data:` container is closed per
+ * type rather than per subType.
+ *
+ * @module
+ */
+
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+
+/**
+ * One step of the market scale.
+ *
+ * @typedef {object} MarketClass
+ * @property {number} value - The integer a note writes.
+ * @property {string} name - What a settlement of this class is called.
+ * @property {string} trade - What can be had there.
+ */
+
+/**
+ * The market scale, in order, from the settlement with no market to the one
+ * other markets buy from.
+ *
+ * @type {readonly MarketClass[]}
+ */
+export const MARKET_CLASSES = Object.freeze([
+    Object.freeze({
+        value: 1,
+        name: "hamlet",
+        trade: "no market — what neighbours trade among themselves",
+    }),
+    Object.freeze({
+        value: 2,
+        name: "village",
+        trade: "a weekly market: staples, a smith, what a household cannot make",
+    }),
+    Object.freeze({
+        value: 3,
+        name: "town",
+        trade: "a regular market, most common goods, several trades working full time",
+    }),
+    Object.freeze({
+        value: 4,
+        name: "market town",
+        trade: "a chartered fair, goods carried from a week away, a moneylender",
+    }),
+    Object.freeze({
+        value: 5,
+        name: "city",
+        trade: "anything ordinary, in quantity; foreign goods; a guild structure",
+    }),
+    Object.freeze({
+        value: 6,
+        name: "great city",
+        trade:
+            "the rare and the imported as a matter of course; banking; " +
+            "the market from which other markets buy",
+    }),
+]);
+
+/** The lowest class the scale states. @type {MarketClass} */
+const LOWEST = MARKET_CLASSES[0];
+
+/** The highest class the scale states. @type {MarketClass} */
+const HIGHEST = MARKET_CLASSES[MARKET_CLASSES.length - 1];
+
+/**
+ * The scale's ends, as a finding states them: `1 (hamlet) to 6 (great city)`.
+ *
+ * @returns {string} The phrase.
+ */
+function scale() {
+    return `${LOWEST.value} (${LOWEST.name}) to ${HIGHEST.value} (${HIGHEST.name})`;
+}
+
+/**
+ * Whether a value is one of the classes the scale states.
+ *
+ * A note may write the number quoted, which YAML hands over as a string, so
+ * the value is read as a number before it is compared — the same reading
+ * `matchesKind` gives a `number` field.
+ *
+ * @param {unknown} value - The authored value.
+ * @returns {boolean} Whether it names a class.
+ */
+export function isMarketClass(value) {
+    const n = numberOf(value);
+    return n !== undefined && MARKET_CLASSES.some((entry) => entry.value === n);
+}
+
+/**
+ * The class a value names, or `undefined` for a value that names none.
+ *
+ * @param {unknown} value - The authored value.
+ * @returns {MarketClass|undefined} The class.
+ */
+export function marketClass(value) {
+    const n = numberOf(value);
+    return MARKET_CLASSES.find((entry) => entry.value === n);
+}
+
+/**
+ * A value as the finite number it reads as, or `undefined`.
+ *
+ * @param {unknown} value - The authored value.
+ * @returns {number|undefined} The number.
+ */
+function numberOf(value) {
+    if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+    if (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value))) {
+        return Number(value);
+    }
+    return undefined;
+}
+
+/**
+ * Check a place note's `data.market`.
+ *
+ * The value is one of the classes the scale states, or it is a finding located
+ * at the key's own line. A value that is not a number at all is left alone:
+ * the container's own shape check reports it, and saying so twice would make
+ * one slip read as two.
+ *
+ * @param {object} note - The note, as the link index hands it over.
+ * @returns {object[]} Findings.
+ */
+export function checkMarket(note) {
+    const fm = note?.fm ?? {};
+    const data = fm.data && typeof fm.data === "object" && !Array.isArray(fm.data) ? fm.data : {};
+    const value = data.market;
+    if (value === undefined || value === null) return [];
+    if (numberOf(value) === undefined) return [];
+    if (isMarketClass(value)) return [];
+    return [
+        {
+            file: note.file,
+            ...positionOfFrontmatterPath(note.raw ?? "", ["data", "market"]),
+            severity: "error",
+            message:
+                `\`data.market\` is a market class — a whole number from ${scale()} — ` +
+                `but reads ${JSON.stringify(value)}`,
+        },
+    ];
+}

package/engine/metadata-index.mjs

@@ -386,13 +386,16 @@ export function loadForeignIndexes(config, localPackages, bases = PACKAGE_BASE)
                 // root onto it and resolves in one step — which is the point of
                 // the record naming a path at all.
                 asset: record.asset ?? undefined,
-                // What a place is next to, reachable from and within, carried
-                // so a consumer's lint checks a border across the package
-                // boundary from both ends, and a consumer's map draws the
-                // dependency's places beside its own.
+                // What a place is next to, reachable from and within, and
+                // what an affiliation holds, carried so a consumer's lint
+                // checks a border across the package boundary from both ends,
+                // a consumer's map draws the dependency's places beside its
+                // own, and a consumer's pages list what a dependency's
+                // affiliation holds and what lies within its regions.
                 borders: record.data?.borders ?? undefined,
                 routes: record.data?.routes ?? undefined,
                 parents: record.data?.parents ?? undefined,
+                domains: record.data?.domains ?? undefined,
                 package: pkg,
             });
         }