@heroiclands/package-build 23.12.8 → 24.0.0

package/engine/core-report.mjs

@@ -0,0 +1,169 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * The core report: for each language that must cover the core vocabulary, the
+ * concepts of the list it has no word for.
+ *
+ * The list is the `data.concepts` of the package's `doc` notes. A language
+ * must cover it where it states `data.core: true`. A word covers every
+ * concept its `concept` names, and a language reads the words of its
+ * `data.family` chain as its own. A missing concept is a fact to work through,
+ * never a finding.
+ *
+ * @module
+ */
+
+import { encodeAddresses } from "./address-values.mjs";
+import { isLanguageRecord, languageLineages, noteAddressOf } from "./word-rows.mjs";
+
+/** Whether a value is a plain map. */
+const isMap = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+
+/** The slug a record is written by in a reference, such as `skill-vylari`. */
+const slugOf = (record) => record.address?.slug ?? record.shortcode;
+
+/** The name a language is reported by. */
+const nameOf = (record) =>
+    typeof record.name?.full === "string" && record.name.full ? record.name.full : record.shortcode;
+
+/**
+ * The concept list the records state, in record then authored order. An id
+ * another list repeats keeps its first place.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {Array<{id: string, gloss: string, group: string}>} The concepts.
+ */
+function conceptsOf(records) {
+    const out = [];
+    const seen = new Set();
+    for (const record of records) {
+        const list = record?.data?.concepts;
+        if (!Array.isArray(list)) continue;
+        for (const entry of list) {
+            if (
+                !isMap(entry) ||
+                typeof entry.id !== "string" ||
+                typeof entry.gloss !== "string" ||
+                typeof entry.group !== "string" ||
+                seen.has(entry.id)
+            )
+                continue;
+            seen.add(entry.id);
+            out.push({ id: entry.id, gloss: entry.gloss, group: entry.group });
+        }
+    }
+    return out;
+}
+
+/** The concept ids a word serves. */
+function idsOf(word) {
+    const value = isMap(word) ? word.concept : undefined;
+    return (Array.isArray(value) ? value : [value]).filter((id) => typeof id === "string");
+}
+
+/**
+ * The core report of a set of index records.
+ *
+ * @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}}
+ *   The report, or the problem when there is no concept list or the language
+ *   asked for is none.
+ */
+export function coreReport(records, { language } = {}) {
+    const all = [...records].map((record) => encodeAddresses(record));
+    const concepts = conceptsOf(all);
+    if (!concepts.length)
+        return {
+            about: "concepts",
+            problem: "no note states `data.concepts`, so there is no core vocabulary to cover",
+        };
+    const languages = all.filter(isLanguageRecord);
+    let chosen;
+    if (language === undefined) chosen = languages.filter((record) => record.data?.core === true);
+    else {
+        const want = language.toLowerCase();
+        chosen = languages.filter((record) =>
+            [nameOf(record), record.shortcode, slugOf(record)].some(
+                (key) => String(key).toLowerCase() === want,
+            ),
+        );
+        if (!chosen.length)
+            return {
+                about: "language",
+                problem: `\`${language}\` is no language note: name one by its name, its shortcode or its reference`,
+            };
+    }
+    chosen.sort((a, b) => nameOf(a).localeCompare(nameOf(b)));
+
+    const { languages: byKey, chain } = languageLineages(all);
+    const groups = [...new Set(concepts.map((concept) => concept.group))];
+    return {
+        concepts: concepts.length,
+        languages: chosen.map((record) => {
+            const have = new Set();
+            for (const key of chain(noteAddressOf(record) ?? ""))
+                for (const word of byKey.get(key)?.data?.words ?? [])
+                    for (const id of idsOf(word)) have.add(id);
+            const missing = [];
+            for (const group of groups) {
+                const members = concepts.filter((concept) => concept.group === group);
+                const lacking = members.filter((concept) => !have.has(concept.id));
+                if (lacking.length)
+                    missing.push({
+                        group,
+                        count: lacking.length,
+                        total: members.length,
+                        concepts: lacking.map(({ id, gloss }) => ({ id, gloss })),
+                    });
+            }
+            const lacking = missing.reduce((sum, group) => sum + group.count, 0);
+            return {
+                name: nameOf(record),
+                language: slugOf(record),
+                core: record.data?.core === true,
+                total: concepts.length,
+                covered: concepts.length - lacking,
+                missing,
+            };
+        }),
+    };
+}
+
+/**
+ * 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}.
+ * @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");
+}

package/engine/core-vocabulary.mjs

@@ -0,0 +1,208 @@
+/*
+ * 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 setting's core vocabulary: the concept list a `doc` note states in
+ * `data.concepts`, the `data.core` flag that says a language must cover it, and
+ * the `concept` a word of a language serves.
+ *
+ * This check owns what the values mean, each finding located at the key at
+ * fault:
+ *
+ * - a concept's `id` is lowercase letters, digits and `-`;
+ * - an `id` is stated once in a list, and by one note in the package;
+ * - a concept's `gloss` and `group` are not blank;
+ * - `data.core` is stated on a language only;
+ * - a word's `concept` names entries of the concept list, each once.
+ *
+ * @module
+ */
+
+import { pathLabel as label } from "./data-keys.mjs";
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+import { nearest } from "./near-miss.mjs";
+import { LANGUAGE_SUBTYPE } from "./word-terms.mjs";
+
+/** What a concept's `id` is made of. */
+export const CONCEPT_ID = /^[a-z0-9-]+$/;
+
+/** Whether a value is a plain map. */
+const isMap = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+
+/** A list value, or an empty one. */
+const listOf = (value) => (Array.isArray(value) ? value : []);
+
+/**
+ * The notes of an index that state a concept list, read once per index.
+ *
+ * @type {WeakMap<object, Array<{file: string, ids: Map<string, number>}>>}
+ */
+const stated = new WeakMap();
+
+/**
+ * Each note of the index that states `data.concepts`, with the ids it states
+ * and where each first stands.
+ *
+ * @param {{notes?: Iterable<{file: string, fm?: Record<string, any>}>}} index - The lint index.
+ * @returns {Array<{file: string, ids: Map<string, number>}>} The notes.
+ */
+function listsIn(index) {
+    const known = stated.get(index);
+    if (known) return known;
+    const lists = [];
+    for (const note of index.notes ?? []) {
+        const concepts = note?.fm?.data?.concepts;
+        if (!Array.isArray(concepts)) continue;
+        const ids = new Map();
+        concepts.forEach((entry, at) => {
+            if (isMap(entry) && typeof entry.id === "string" && !ids.has(entry.id))
+                ids.set(entry.id, at);
+        });
+        lists.push({ file: note.file, ids });
+    }
+    stated.set(index, lists);
+    return lists;
+}
+
+/**
+ * Every concept id the index's notes state.
+ *
+ * @param {{notes?: Iterable<object>}|undefined} index - The lint index.
+ * @returns {Set<string>|undefined} The ids, or `undefined` without an index.
+ */
+export function conceptIdsIn(index) {
+    if (!index?.notes) return undefined;
+    return new Set(listsIn(index).flatMap((list) => [...list.ids.keys()]));
+}
+
+/**
+ * Check a `doc` note's `data.concepts`: each id's spelling, an id stated twice,
+ * an id another note states, and a blank `gloss` or `group`.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
+ * @param {{index?: {notes?: Iterable<object>}}} [context] - The lint index.
+ * @returns {object[]} The findings, each at its key.
+ */
+export function checkConceptList(note, { index } = {}) {
+    const concepts = note?.fm?.data?.concepts;
+    if (!Array.isArray(concepts)) return [];
+    const raw = note.raw ?? "";
+    const finding = (path, message) => ({
+        file: note.file,
+        ...positionOfFrontmatterPath(raw, path),
+        severity: "error",
+        message,
+    });
+    const others = index ? listsIn(index).filter((list) => list.file !== note.file) : [];
+    const findings = [];
+    const seen = new Set();
+    concepts.forEach((entry, at) => {
+        if (!isMap(entry)) return;
+        const where = (key) => ["data", "concepts", at, key];
+        if (typeof entry.id === "string") {
+            if (!CONCEPT_ID.test(entry.id))
+                findings.push(
+                    finding(
+                        where("id"),
+                        `\`${label(where("id"))}\` is \`${entry.id}\`; a concept's id is lowercase letters, digits and \`-\``,
+                    ),
+                );
+            else if (seen.has(entry.id))
+                findings.push(
+                    finding(
+                        where("id"),
+                        `\`${entry.id}\` is stated twice in this list; a concept's id is unique`,
+                    ),
+                );
+            else {
+                const also = others.find((list) => list.ids.has(entry.id));
+                if (also)
+                    findings.push(
+                        finding(
+                            where("id"),
+                            `\`${entry.id}\` is also stated by ${also.file}; a concept's id is unique`,
+                        ),
+                    );
+            }
+            seen.add(entry.id);
+        }
+        for (const key of ["gloss", "group"])
+            if (typeof entry[key] === "string" && entry[key].trim() === "")
+                findings.push(
+                    finding(where(key), `\`${label(where(key))}\` is blank; state the ${key}`),
+                );
+    });
+    return findings;
+}
+
+/**
+ * Check a `skill` note's `data.core`: stated on a language only.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - A `skill` note.
+ * @returns {object[]} The findings.
+ */
+export function checkCoreFlag(note) {
+    const fm = note?.fm ?? {};
+    if (!isMap(fm.data) || fm.data.core === undefined || fm.data.core === null) return [];
+    if (String(fm.subType ?? "").toLowerCase() === LANGUAGE_SUBTYPE) return [];
+    return [
+        {
+            file: note.file,
+            ...positionOfFrontmatterPath(note.raw ?? "", ["data", "core"], { key: true }),
+            severity: "error",
+            message:
+                "`data.core` says a language must cover the core vocabulary, and this note's " +
+                `\`subType\` is not \`${LANGUAGE_SUBTYPE}\``,
+        },
+    ];
+}
+
+/**
+ * What is wrong with a word's `concept`: an id the list does not declare, and
+ * an id stated twice.
+ *
+ * @param {unknown} value - The word's `concept`: an id, or a list of them.
+ * @param {Set<string>|undefined} known - The ids the index declares, or
+ *   `undefined` where there is no index to check against.
+ * @returns {Array<{entry: number|null, message: string}>} Each problem and the
+ *   list entry it sits at, `null` for a single id.
+ */
+export function conceptProblems(value, known) {
+    if (!known) return [];
+    const single = typeof value === "string";
+    const entries = single ? [value] : listOf(value);
+    const problems = [];
+    const seen = new Set();
+    entries.forEach((id, at) => {
+        if (typeof id !== "string") return;
+        const entry = single ? null : at;
+        if (seen.has(id)) {
+            problems.push({
+                entry,
+                message: `\`${id}\` is stated twice in this word's \`concept\``,
+            });
+            return;
+        }
+        seen.add(id);
+        if (known.has(id)) return;
+        const near = nearest(id, known);
+        problems.push({
+            entry,
+            message:
+                known.size ?
+                    `\`${id}\` is not a core concept${near ? `; did you mean \`${near}\`?` : ""}`
+                :   `\`${id}\` is not a core concept: no note states \`data.concepts\``,
+        });
+    });
+    return problems;
+}

package/engine/dictionary-html.mjs

@@ -0,0 +1,119 @@
+/*
+ * 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
+ */
+
+/**
+ * **Dictionary rows in finished HTML.** {@link groupDictionaryLists} gives a
+ * definition list written as HTML the rows and the `dictionary` class that
+ * {@link module:engine/definition-list.dictionaryListPlugin} gives one written
+ * in Markdown, so both read the same on a page.
+ *
+ * The page is read as tokens, and a stack of open elements gives each nested
+ * list its own rows. Comments, `script`, `style`, `pre` and `textarea` are
+ * opaque: a literal example inside one is left as written. A list that already
+ * has rows keeps them.
+ *
+ * @module
+ */
+
+/** One token: a comment, an opaque element, a declaration, a tag, text, or a bare `<`. */
+const TOKEN =
+    /<!--[^]*?-->|<script\b(?:[^"'<>]|"[^"]*"|'[^']*')*>[^]*?<\/script\s*>|<style\b(?:[^"'<>]|"[^"]*"|'[^']*')*>[^]*?<\/style\s*>|<pre\b(?:[^"'<>]|"[^"]*"|'[^']*')*>[^]*?<\/pre\s*>|<textarea\b(?:[^"'<>]|"[^"]*"|'[^']*')*>[^]*?<\/textarea\s*>|<![^>]*>|<\/?[a-z][a-z0-9:-]*(?:[^"'<>]|"[^"]*"|'[^']*')*>|[^<]+|</gi;
+
+/** Elements with no closing tag. */
+const VOID = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr",
+]);
+
+/** Add the `dictionary` class to a `<dl …>` opening tag. */
+function withDictionaryClass(token) {
+    if (
+        /\sclass\s*=\s*["'](?:[^"']*\s)?dictionary(?:\s|["'])/i.test(token) ||
+        /\sclass\s*=\s*dictionary(?:\s|>)/i.test(token)
+    )
+        return token;
+    if (/\sclass\s*=\s*["']/i.test(token))
+        return token.replace(/(\sclass\s*=\s*["'])/i, "$1dictionary ");
+    if (/\sclass\s*=/i.test(token))
+        return token.replace(/(\sclass\s*=\s*)([^\s>]+)/i, '$1"dictionary $2"');
+    return token.replace(/^<dl/i, '<dl class="dictionary"');
+}
+
+/**
+ * Group each term of every definition list with its definitions.
+ *
+ * @param {string} html - A page's HTML.
+ * @returns {string} The HTML with a `dictionary` class on each `dl` and a `div`
+ *   around each term and the definitions that follow it.
+ */
+export function groupDictionaryLists(html) {
+    const source = String(html ?? "");
+    if (!/<dl(?:\s|>)/i.test(source)) return source;
+    const tokens = source.match(TOKEN) ?? [];
+    const parts = [];
+    const lists = [];
+    const elements = [];
+    tokens.forEach((original, i) => {
+        let token = original;
+        const previous = tokens[i - 1];
+        const next = tokens[i + 1];
+        // Whitespace between a term and its definition, and between a definition's
+        // opening and its first paragraph, would add a word space to a fixed gap.
+        if (
+            lists.length &&
+            i > 0 &&
+            next !== undefined &&
+            /^\s+$/.test(token) &&
+            ((/^<\/dt\s*>$/i.test(previous) && /^<dd(?:\s|>)/i.test(next)) ||
+                (/^<dd(?:\s[^>]*)?>$/i.test(previous) && /^<p(?:\s|>)/i.test(next)))
+        )
+            token = "";
+        const opaque = /^<(?:!--|script\b|style\b|pre\b|textarea\b)/i.test(token);
+        if (!opaque && /^<\/?[a-z]/i.test(token)) {
+            const tag = token.replace(/^<\/?([a-z][a-z0-9:-]*)[^]*$/i, "$1").toLowerCase();
+            const closing = token.startsWith("</");
+            if (tag === "dl" && !closing) {
+                lists.push({ row: false });
+                token = withDictionaryClass(token);
+            } else if (tag === "dt" && !closing && lists.length && elements.at(-1) === "dl") {
+                const list = lists.at(-1);
+                if (list.row) parts.push("</div>");
+                parts.push("<div>");
+                list.row = true;
+            } else if (tag === "dl" && closing && lists.length) {
+                const list = lists.at(-1);
+                if (list.row) parts.push("</div>");
+                lists.pop();
+            }
+            if (closing) {
+                if (elements.length) elements.pop();
+            } else if (!(/\/\s*>$/.test(token) || VOID.has(tag))) {
+                elements.push(tag);
+            }
+        }
+        parts.push(token);
+    });
+    return parts.join("");
+}

package/engine/dictionary-rows.mjs

@@ -143,12 +143,23 @@ const defines = (entry) => typeof entry.definition === "string" && entry.definit
 export function pluralOf(word, grammar) {
     if (parseWordClass(word.class).base !== "n") return null;
     if (typeof word.plural === "string" && word.plural) return word.plural;
+    return pluralByRule(word.form, grammar);
+}
+
+/**
+ * The plural a language's `data.grammar.plural` rule gives a form: the first
+ * literal ending replacement that fits, whatever the form's class.
+ *
+ * @param {string} form - The form.
+ * @param {Record<string, any>|undefined} grammar - Its language's
+ *   `data.grammar`.
+ * @returns {string|null} The plural, or `null` where no rule fits.
+ */
+export function pluralByRule(form, grammar) {
     for (const rule of Array.isArray(grammar?.plural) ? grammar.plural : []) {
         if (typeof rule?.ending !== "string" || typeof rule.becomes !== "string") continue;
-        if (word.form.endsWith(rule.ending))
-            return (
-                (rule.ending ? word.form.slice(0, -rule.ending.length) : word.form) + rule.becomes
-            );
+        if (form.endsWith(rule.ending))
+            return (rule.ending ? form.slice(0, -rule.ending.length) : form) + rule.becomes;
     }
     return null;
 }

package/engine/field-reference.mjs

@@ -35,7 +35,7 @@
  */
 
 import path from "node:path";
-import matter from "gray-matter";
+import { writeMatter } from "./note-matter.mjs";
 import { formatNoteFrontmatter } from "./note-format.mjs";
 
 import { authoredFields, runtimeOnlyFields } from "./field-spec.mjs";
@@ -368,7 +368,7 @@ function deepMerge(base, overlay) {
  * The one question that decides whether `docs item-fields` writes a note
  * envelope: `assets/content/` walks every file under it for its `type:`, so a
  * generated page filed there needs one to publish at all, while a page filed
- * anywhere else — a repository's own `docs/` — is read by nobody but Hugo's
+ * anywhere else — a repository's own `docs/` — is read by nobody but the
  * `--check` guard and the reader following a link, neither of which wants
  * frontmatter.
  *
@@ -422,7 +422,7 @@ export function shortcodeFromBasename(destination) {
  *   {@link shortcodeFromBasename}.
  * @param {Record<string, unknown>} [options.frontmatter] - The consumer's
  *   declared `docs.itemFields.frontmatter`.
- * @returns {Record<string, unknown>} The envelope, ready for `matter.stringify`.
+ * @returns {Record<string, unknown>} The envelope, ready for `writeMatter`.
  */
 export function itemFieldsEnvelope({ title, shortcode, frontmatter }) {
     return deepMerge(
@@ -464,8 +464,8 @@ export function renderItemFieldsPage(body, { title, destination, contentRoot, fr
         shortcode: shortcodeFromBasename(destination),
         frontmatter,
     });
-    const page = matter.stringify(body, envelope);
-    // `matter.stringify` closes the frontmatter fence directly onto the
+    const page = writeMatter(body, envelope);
+    // `writeMatter` closes the frontmatter fence directly onto the
     // body's first line; Prettier's markdown printer requires a blank line
     // between them, so a page written without one fails a consumer's
     // `lint:format` the moment it is committed. Insert it here rather than

package/engine/first-use.mjs

@@ -83,6 +83,14 @@ function readLabel(text, env = {}) {
 }
 const labelText = (text, env) => readLabel(text, env).text;
 
+/** The kind a span's `data-type` supplies; an invalid value is refused by the span check. */
+function spanKind(span) {
+    const value = span.attrs?.find(([key]) => key === "data-type")?.[1];
+    if (typeof value !== "string") return undefined;
+    const [type, subType] = value.split("/");
+    return { type, subType: subType ?? null };
+}
+
 /** Join overlapping source ranges so lookups stay logarithmic. */
 function ranges(values) {
     const out = [];
@@ -119,7 +127,6 @@ function prose(source, capturedNames) {
     const links = [],
         regions = [],
         excluded = [],
-        bold = [],
         html = [];
     const masked = source
         .replace(/!\[\[[^\]\n]+\]\]|\{\{[^}\n]+\}\}/g, (text, start) => {
@@ -142,7 +149,6 @@ function prose(source, capturedNames) {
             excluded.push({ start, end });
         else if (node.type === "html") html.push(node);
         else if (["strong", "emphasis", "delete", "link", "linkReference"].includes(node.type)) {
-            if (node.type === "strong") bold.push({ start, end });
             if (["link", "linkReference"].includes(node.type) && source[start] === "[")
                 links.push({ start, end, labelled: true });
             for (const child of node.children ?? []) inline(child);
@@ -224,18 +230,8 @@ function prose(source, capturedNames) {
     const linked = ranges(authoredLinks);
     const marked = (capturedNames ?? scanSpans(source).names)
         .filter((span) => eligible(span) && !contains(linked, span))
-        .map((span) => ({ ...span, label: span.visible }));
-    const explicit = ranges([...marked, ...authoredLinks]);
-    return {
-        marked,
-        links: authoredLinks,
-        bold: bold
-            .filter((span) => eligible(span) && !overlaps(explicit, span))
-            .map((span) => ({
-                ...span,
-                label: labelText(source.slice(span.start, span.end), env),
-            })),
-    };
+        .map((span) => ({ ...span, label: span.visible, nameKind: spanKind(span) }));
+    return { marked, links: authoredLinks };
 }
 
 /**
@@ -264,7 +260,7 @@ export function createFirstUseChecker({
                     { raw, bodyLine: authored.bodyLine, bodyColumn: authored.bodyColumn },
                 )
             :   undefined;
-        const { marked, links, bold } = prose(raw, capturedNames);
+        const { marked, links } = prose(raw, capturedNames);
         const events = [
             ...marked.map((span) => ({ ...span, kind: "marked" })),
             ...links.map((link) => {
@@ -286,7 +282,10 @@ export function createFirstUseChecker({
         for (const event of [...events].sort(
             (a, b) => a.label.length - b.label.length || a.label.localeCompare(b.label),
         )) {
-            if (recognized(event.label, event.preferred) || unknown.has(normalize(event.label)))
+            if (
+                recognized(event.label, event.preferred, event.nameKind) ||
+                unknown.has(normalize(event.label))
+            )
                 continue;
             const entry = {
                 key: "name:" + normalize(event.label),
@@ -309,7 +308,8 @@ export function createFirstUseChecker({
             fullUsed = new Set();
         for (const event of events.sort((a, b) => a.start - b.start)) {
             const entry =
-                recognized(event.label, event.preferred) ?? unknown.get(normalize(event.label));
+                recognized(event.label, event.preferred, event.nameKind) ??
+                unknown.get(normalize(event.label));
             if (event.kind === "marked" && entry.indexed) {
                 const destinations = (entry.candidates ?? [entry])
                     .map((target) => target.key)
@@ -338,16 +338,6 @@ export function createFirstUseChecker({
             used.add(entry.key);
             if (introduces) fullUsed.add(entry.key);
         }
-        for (const span of bold) {
-            if (typeof span.label !== "string") continue;
-            const entry = recognized(span.label);
-            if (entry)
-                add(
-                    span.start,
-                    "bold-name",
-                    `“${span.label}” matches an indexed name; mark or link this name`,
-                );
-        }
         const lineStarts = [0];
         for (let i = 0; i < raw.length; i++) if (raw[i] === "\n") lineStarts.push(i + 1);
         return [...findings]

package/engine/frontmatter-lint.mjs

@@ -813,7 +813,7 @@ function checkKeyedMap(note, { field, segments, entries, raw, packs }) {
  * lands at — would mean checking the value against the sections that could
  * exist (every content type, plus whatever a repository configured) rather
  * than against the genres its type declares. Two vocabularies in one field is
- * the cause, and it is removed rather than the symptom: a section is a Hugo
+ * the cause, and it is removed rather than the symptom: a section is a
  * directory the note format does not
  * carry, and a page introducing a type is an ordinary note addressed
  * `doc-<type>`. So the closed list answers for every note, whatever it is