@heroiclands/package-build 23.3.1 → 23.4.0

package/engine/culture-parents.mjs

@@ -0,0 +1,301 @@
+/*
+ * 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
+ */
+
+import { isDeepStrictEqual } from "node:util";
+import { canonicalKey, parseAddress, renderAddress } from "./address.mjs";
+import { positionOfFrontmatterPath, formatDiagnostic } from "./diagnostics.mjs";
+
+const fields = ["language", "appearanceProfile"];
+const payload = (note) => note.fm ?? note;
+const dataOf = (note) => payload(note).data ?? payload(note);
+const culture = (note) => payload(note).type === "lore" && payload(note).subType === "culture";
+const parentsOf = (note) => (Array.isArray(dataOf(note).parents) ? dataOf(note).parents : []);
+
+/** Read a culture parent against the field's Address defaults. */
+function address(value, index) {
+    const tuple = parseAddress(value, {
+        package: index.contentPackage,
+        system: "note",
+        type: "lore",
+        types: index.types,
+        packages: index.packages,
+    });
+    return tuple.reason ? undefined : tuple;
+}
+
+/** The authored edge graph, with every cyclic edge identified. */
+function graph(index) {
+    const out = new Map();
+    const queue = [...(index.notes ?? [])].filter(culture);
+    while (queue.length) {
+        const note = queue.pop();
+        if (out.has(note)) continue;
+        const edges = [];
+        out.set(note, edges);
+        parentsOf(note).forEach((value, position) => {
+            const tuple = address(value, index);
+            if (!tuple || tuple.type !== "lore") return;
+            const target = index.addressHit?.(renderAddress(tuple));
+            if (!target || !culture(target)) return;
+            edges.push({ target, position });
+            queue.push(target);
+        });
+    }
+    const reaches = (start, end) => {
+        const seen = new Set();
+        const queue = [start];
+        while (queue.length) {
+            const current = queue.pop();
+            if (current === end) return true;
+            if (seen.has(current)) continue;
+            seen.add(current);
+            queue.push(...(out.get(current) ?? []).map((edge) => edge.target));
+        }
+        return false;
+    };
+    const cyclic = new Map();
+    for (const [note, edges] of out)
+        cyclic.set(
+            note,
+            new Set(
+                edges.filter((edge) => reaches(edge.target, note)).map((edge) => edge.position),
+            ),
+        );
+    return { out, cyclic };
+}
+
+/** A located hierarchy finding with the Address of the culture it concerns. */
+function finding(note, index, path, message) {
+    const fm = payload(note);
+    return {
+        file: note.file,
+        ...positionOfFrontmatterPath(note.raw ?? "", ["data", "parents", ...path]),
+        severity: "error",
+        code: "culture-parents",
+        cultureAddress: canonicalKey(index.contentPackage, "note", "lore", fm.shortcode),
+        parentIndex: path[0],
+        message,
+    };
+}
+
+/** Validate subtype scope and culture targets; unresolved targets use the ordinary reference check. */
+function parentFindings(note, index, analysis, unresolved) {
+    const data = dataOf(note);
+    if (data.parents === undefined || data.parents === null) return [];
+    if (!culture(note))
+        return [finding(note, index, [], "data.parents is stated by only culture lore notes")];
+    const findings = [];
+    parentsOf(note).forEach((value, position) => {
+        const tuple = address(value, index);
+        if (!tuple) return;
+        const key = renderAddress(tuple);
+        const target = tuple.type === "lore" ? index.addressHit?.(key) : undefined;
+        if (tuple.type !== "lore") {
+            if (unresolved)
+                findings.push(
+                    finding(
+                        note,
+                        index,
+                        [position],
+                        `data.parents.${position} accepts lore, not ${tuple.type}`,
+                    ),
+                );
+        } else if (!target) {
+            if (unresolved)
+                findings.push(
+                    finding(
+                        note,
+                        index,
+                        [position],
+                        `data.parents.${position} names ${key}, which does not resolve in this package or its declared dependencies`,
+                    ),
+                );
+        } else if (!culture(target))
+            findings.push(
+                finding(
+                    note,
+                    index,
+                    [position],
+                    `data.parents.${position} names ${key}, whose subType is not culture`,
+                ),
+            );
+        else if (analysis.cyclic.get(note)?.has(position))
+            findings.push(
+                finding(
+                    note,
+                    index,
+                    [position],
+                    `data.parents.${position} forms a culture parent cycle; a culture is never its own ancestor`,
+                ),
+            );
+    });
+    return findings;
+}
+
+const graphs = new WeakMap();
+const hierarchyProblems = new WeakMap();
+const inheritedFields = new WeakMap();
+const inheritedSources = new WeakMap();
+
+/** The authored source of one inherited field, retained outside the published record. */
+export function cultureFieldSource(records, key, field) {
+    const record = records.find(
+        (entry) =>
+            entry.type === "lore" &&
+            entry.subType === "culture" &&
+            canonicalKey(entry.package, "note", "lore", entry.shortcode) === key,
+    );
+    return record && inheritedSources.get(record)?.get(field);
+}
+
+/** Fields supplied by an ancestor rather than authored on this record. */
+export function cultureInheritedFields(record) {
+    return inheritedFields.get(record);
+}
+
+/** Read the hierarchy findings retained beside a resolved index record. */
+export function cultureRecordProblems(record) {
+    return hierarchyProblems.get(record);
+}
+
+/** Read hierarchy findings attached to one culture's resolved index record. */
+export function cultureHierarchyProblems(records, key) {
+    return records.flatMap((record) =>
+        (
+            record.type === "lore" &&
+            record.subType === "culture" &&
+            canonicalKey(record.package, "note", "lore", record.shortcode) === key
+        ) ?
+            (hierarchyProblems.get(record) ?? [])
+        :   [],
+    );
+}
+
+/**
+ * Check the declared culture-parent field in the normal frontmatter lint.
+ * @param {object} note - The note's frontmatter and source location.
+ * @param {{index?: object}} [options] - The corpus and its Address lookup.
+ * @returns {object[]} Located findings.
+ */
+export function checkCultureParents(note, { index } = {}) {
+    if (note.reportedCultureParents) return [];
+    const context = index ?? { contentPackage: undefined, notes: [note] };
+    let analysis = graphs.get(context);
+    if (!analysis) {
+        analysis = graph(context);
+        graphs.set(context, analysis);
+    }
+    return parentFindings(note, context, analysis, false);
+}
+
+/**
+ * Resolve each omitted culture field independently, searching parents in listed depth-first order.
+ * Same-depth disagreement withholds the inherited field and produces a finding.
+ * @param {object} index - The authored culture nodes and Address lookup.
+ * @returns {{values: Map<object, object>, findings: object[]}}
+ */
+export function cultureInheritance(index) {
+    const analysis = graph(index);
+    const findings = [];
+    const values = new Map();
+    for (const note of index.notes ?? []) {
+        if (!culture(note)) continue;
+        findings.push(...parentFindings(note, index, analysis, true));
+        const inherited = {};
+        const sources = new Map();
+        for (const field of fields) {
+            if (dataOf(note)[field] !== undefined) continue;
+            const candidates = [];
+            const work = [{ node: note, depth: 0 }];
+            const seen = new Map();
+            while (work.length) {
+                const { node, depth, via } = work.pop();
+                if (analysis.cyclic.get(node)?.size) continue;
+                if (seen.has(node) && seen.get(node) <= depth) continue;
+                seen.set(node, depth);
+                const value = dataOf(node)[field];
+                if (depth && value !== undefined) {
+                    candidates.push({ value, depth, via, node });
+                    continue;
+                }
+                const edges = analysis.out.get(node) ?? [];
+                for (let i = edges.length - 1; i >= 0; i--) {
+                    const edge = edges[i];
+                    if (!analysis.cyclic.get(node)?.has(edge.position))
+                        work.push({
+                            node: edge.target,
+                            depth: depth + 1,
+                            via: depth ? via : edge.position,
+                        });
+                }
+            }
+            const atDepth = new Map();
+            let conflicting;
+            for (const candidate of candidates) {
+                if (
+                    atDepth.has(candidate.depth) &&
+                    !isDeepStrictEqual(atDepth.get(candidate.depth), candidate.value)
+                )
+                    conflicting = candidate;
+                else atDepth.set(candidate.depth, candidate.value);
+            }
+            if (conflicting)
+                findings.push(
+                    finding(
+                        note,
+                        index,
+                        [conflicting.via],
+                        `culture parents at the same depth disagree on data.${field}; state the field on this culture`,
+                    ),
+                );
+            else if (candidates.length) {
+                inherited[field] = candidates[0].value;
+                const source = candidates[0].node;
+                sources.set(field, { file: source.file, raw: source.raw, fm: payload(source) });
+            }
+        }
+        inheritedSources.set(payload(note), sources);
+        values.set(note, inherited);
+    }
+    for (const note of index.notes ?? []) {
+        if (!culture(note)) continue;
+        inheritedFields.set(payload(note), new Set(Object.keys(values.get(note) ?? {})));
+        const relevant = new Set();
+        const work = [note];
+        while (work.length) {
+            const current = work.pop();
+            if (relevant.has(current)) continue;
+            relevant.add(current);
+            work.push(...(analysis.out.get(current) ?? []).map((edge) => edge.target));
+        }
+        const addresses = new Set(
+            [...relevant].map((entry) =>
+                canonicalKey(index.contentPackage, "note", "lore", payload(entry).shortcode),
+            ),
+        );
+        hierarchyProblems.set(
+            payload(note),
+            findings.filter((problem) => addresses.has(problem.cultureAddress)),
+        );
+    }
+    return { values, findings };
+}
+
+/** Emit or collect all findings from culture inheritance. */
+export function reportCultureParents(findings, problems) {
+    if (problems) problems.push(...findings);
+    else if (findings.length)
+        throw Object.assign(new Error(findings.map(formatDiagnostic).join("\n")), {
+            located: true,
+        });
+}

package/engine/data-keys.mjs

@@ -185,7 +185,8 @@ export function mapEntriesOf(value) {
  *
  * @param {readonly object[]} fields - The type's `data:` declaration.
  * @returns {object[]} One spec per top-level key, a dotted group as a `map`
- *   whose `fields` are its members, with `grouped: true`.
+ *   whose `fields` are its members, with `grouped: true`, and each member
+ *   marked `kindChecked`.
  */
 export function topLevelSpecs(fields) {
     const out = [];
@@ -202,7 +203,10 @@ export function topLevelSpecs(fields) {
             groups.set(head, group);
             out.push(group);
         }
-        group.members.push({ ...field, name: rest.join(".") });
+        // The frontmatter lint's container check has already held a dotted
+        // field's leaf to its kind; `kindChecked` keeps the walk from saying
+        // so a second time.
+        group.members.push({ ...field, name: rest.join("."), kindChecked: true });
     }
     for (const group of groups.values()) {
         group.fields = topLevelSpecs(group.members);
@@ -285,6 +289,7 @@ export function checkDataKeys(note, fields) {
     const visit = (spec, value, path) => {
         if (value === undefined || value === null) return;
         if (!fitsKind(value, spec.kind)) {
+            if (spec.kindChecked && !spec.fields) return;
             findings.push(
                 finding(
                     path,

package/engine/docs-checks.mjs

@@ -29,11 +29,39 @@ function* markdownFiles(root) {
 
 /** Preserve offsets while excluding literal examples from link scanning. */
 export function maskMarkdownCode(source, spans = true) {
-    const pattern =
-        spans ?
-            /```[\s\S]*?```|~~~[\s\S]*?~~~|``[^`]*``|`[^`]*`/g
-        :   /```[\s\S]*?```|~~~[\s\S]*?~~~/g;
-    return source.replace(pattern, (match) => match.replace(/[^\n]/g, " "));
+    const mask = (value) => value.replace(/[^\n]/g, " ");
+    let fence;
+    let body = "";
+    for (const line of source.match(/[^\n]*\n|[^\n]+$/g) || []) {
+        if (fence) {
+            body += mask(line);
+            const close = line.match(/^ {0,3}(`+|~+)[ \t]*\r?\n?$/);
+            if (close && close[1][0] === fence[0] && close[1].length >= fence.length)
+                fence = undefined;
+        } else {
+            const open = line.match(/^ {0,3}(`{3,}|~{3,})(.*)/);
+            if (open && (open[1][0] !== "`" || !open[2].includes("`"))) {
+                fence = open[1];
+                body += mask(line);
+            } else body += line;
+        }
+    }
+    if (!spans) return body;
+    const delimiters = [...body.matchAll(/`+/g)];
+    let offset = 0;
+    let result = "";
+    for (let i = 0; i < delimiters.length; i++) {
+        const start = delimiters[i];
+        const end = delimiters.findIndex(
+            (candidate, index) => index > i && candidate[0].length === start[0].length,
+        );
+        if (end < 0) continue;
+        const stop = delimiters[end].index + delimiters[end][0].length;
+        result += body.slice(offset, start.index) + mask(body.slice(start.index, stop));
+        offset = stop;
+        i = end;
+    }
+    return result + body.slice(offset);
 }
 
 /** GitHub heading slug, retaining separate spaces after punctuation removal. */
@@ -50,11 +78,16 @@ export function docHeadingSlug(value) {
 export function docAnchors(source) {
     const body = maskMarkdownCode(source, false);
     const anchors = new Set();
+    const suffixes = new Map();
     for (const [, heading] of body.matchAll(/^#{1,6}\s+(.+?)\s*#*$/gm)) {
         const explicit = splitHeadingAttributes(heading);
-        anchors.add(
-            explicit.id || docHeadingSlug(explicit.text.replace(/\[([^\]]*)\]\([^)]*\)/g, "$1")),
-        );
+        const base =
+            explicit.id || docHeadingSlug(explicit.text.replace(/\[([^\]]*)\]\([^)]*\)/g, "$1"));
+        let anchor = base;
+        let suffix = suffixes.get(base) || 0;
+        while (anchors.has(anchor)) anchor = `${base}-${++suffix}`;
+        suffixes.set(base, suffix);
+        anchors.add(anchor);
     }
     for (const [, anchor] of body.matchAll(/<a\s[^>]*(?:id|name)="([^"]+)"/g)) {
         anchors.add(anchor);

package/engine/frontmatter-lint.mjs

@@ -412,6 +412,7 @@ function checkDataContainer(note, { type, fields, packs, addressContext, index }
     }
 
     for (const field of fields) {
+        if (note.inheritedCultureFields?.has(field.name)) continue;
         if (!field.kind) continue;
         const segments = field.name.split(".");
         let value = entries;
@@ -457,7 +458,12 @@ function checkDataContainer(note, { type, fields, packs, addressContext, index }
 
     // One level down and every level below: each field's value is closed to
     // the inner keys its declaration states, as the container is to its own.
-    findings.push(...checkDataKeys(note, fields));
+    findings.push(
+        ...checkDataKeys(
+            note,
+            fields.filter((field) => !note.inheritedCultureFields?.has(field.name)),
+        ),
+    );
 
     return findings;
 }
@@ -600,6 +606,13 @@ function checkDataReferences(note, field, value, segments, context, index) {
                     :   `; write \`${slot.declines}\` to decline the image on purpose`);
         }
         if (!reason) continue;
+        if (
+            note.fm?.type === "lore" &&
+            note.fm?.subType === "culture" &&
+            field.name === "parents" &&
+            note.reportedCultureParents?.has(check.path[0])
+        )
+            continue;
         const path = ["data", ...segments, ...check.path];
         findings.push({
             file: note.file,
@@ -1526,6 +1539,7 @@ export function lintNote(
         // way a wikilink would. The linter names no such field itself; the
         // vocabulary does, beside the field.
         for (const field of fields) {
+            if (note.inheritedCultureFields?.has(field.name)) continue;
             if (typeof field.check !== "function") continue;
             findings.push(...field.check(note, { index }));
         }

package/engine/infobox.mjs

@@ -506,15 +506,15 @@ export function humanizeValue(value) {
 /**
  * Several enumerated values as one clause — `weathered, ruddy and scarred`.
  *
- * A field that admits one value or a list of them reads as a single phrase, so
- * the noun it qualifies is said once rather than once per value. Internal: the
- * phrase that wants it is declared in this module.
+ * A list field reads as a single phrase, so the noun it qualifies is said
+ * once rather than once per value. Internal: the phrase that wants it is
+ * declared in this module.
  *
- * @param {unknown} value - One value, or a list of them.
+ * @param {unknown} value - A list of values.
  * @returns {string} The text.
  */
 function humanizedList(value) {
-    const parts = (Array.isArray(value) ? value : [value])
+    const parts = (Array.isArray(value) ? value : [])
         .filter((entry) => entry !== undefined && entry !== null && entry !== "")
         .map((entry) => humanizeValue(entry));
     if (parts.length < 2) return parts[0] ?? "";

package/engine/metadata-index.mjs

@@ -484,6 +484,17 @@ export function loadForeignIndexes(config, localPackages, bases = PACKAGE_BASE)
                 // place or affiliation inherits from a parent here without
                 // walking that parent's own chain.
                 culture: record.data?.culture ?? undefined,
+                ...(parts.type === "lore" && record.subType === "culture" ?
+                    {
+                        data: {
+                            language: record.data?.language,
+                            appearanceProfile: record.data?.appearanceProfile,
+                        },
+                    }
+                :   {}),
+                ...(parts.type === "skill" && record.subType === "language" ?
+                    { data: { names: record.data?.names } }
+                :   {}),
                 population: record.data?.population ?? undefined,
                 ...(Object.hasOwn(record.data ?? {}, "government") ?
                     { government: record.data.government }

package/engine/note-vocabulary.mjs

@@ -111,11 +111,13 @@ import { checkNoteEvents } from "./note-events.mjs";
 import { AFFILIATION_STANDINGS } from "../sohl/affiliation-standings.mjs";
 import { EVENT_ENTRY } from "./note-event-terms.mjs";
 import { CULTURE_FIELD, checkCultureSubType } from "./culture-choice.mjs";
+import { checkCultureParents } from "./culture-parents.mjs";
 import {
     checkAppearanceProfile,
     profileLookKeys,
     requiredHeightGenders,
 } from "./appearance-profile.mjs";
+import { checkExtraFeatures } from "./appearance-features.mjs";
 import { LANGUAGE_FIELD, LITERATURE_FIELDS, checkLiteratureNote } from "./literature-notes.mjs";
 import { checkLanguageNames, requiredGivenGenders } from "./language-names.mjs";
 import { SOCIAL_TIES, SOCIAL_TIE_TARGET_TYPES } from "./social-tie-terms.mjs";
@@ -271,9 +273,9 @@ function lookWords(rows) {
  *
  * Each field is closed to its list: any other value, an empty one included, is
  * a finding at the value naming the words it takes. `appearance.complexion`
- * takes one word or a list of them, and each entry is checked on its own.
- * `appearance.extra_features` is not here: it is free text, a list of the marks
- * no word covers.
+ * is a list of words, each entry checked on its own. `appearance.extra_features`
+ * is not here: it is a list of the physical marks no word covers, held to the
+ * rules of `appearance-features.mjs`.
  *
  * @type {Readonly<Record<string, readonly LookWord[]>>}
  */
@@ -595,15 +597,18 @@ const TEXT_LIST = Object.freeze({
 });
 
 /**
- * One value, or several.
- *
- * The two are the same fact at different lengths rather than two different
- * facts, so a single value means a list of one and a consumer reads one shape.
+ * A being's complexion: a list of complexion words, `[]` included. The shape
+ * names the list form, because the finding an author meets for a single word
+ * quotes it.
  */
-const TEXT_OR_LIST = Object.freeze({
-    shape: "string or list",
-    kind: "string-or-list",
-    entries: Object.freeze({ kind: "string", shape: "a string" }),
+const COMPLEXION_LIST = Object.freeze({
+    shape: "a list of words, such as `[weathered]` or `[]`",
+    kind: "list",
+    entries: Object.freeze({
+        kind: "string",
+        shape: "a string",
+        allowed: lookValues("appearance.complexion"),
+    }),
 });
 
 /** A single Address. */
@@ -1453,22 +1458,26 @@ export const NOTE_VOCABULARY = Object.freeze({
             lookField("appearance.skin_color", "Skin colour"),
             {
                 ...lookField("appearance.complexion", "The skin's condition"),
-                ...TEXT_OR_LIST,
+                ...COMPLEXION_LIST,
+                required: true,
                 describe:
-                    `The skin's condition: ${wordList(lookValues("appearance.complexion"))}, ` +
-                    "one word or a list of several, because a face carries more than one at " +
-                    "once. A single word means a list of one. See " +
+                    `The skin's condition, as a list of ${wordList(lookValues("appearance.complexion"))}: ` +
+                    "`[weathered, freckled]`, `[clear]` for unremarked skin, or `[]` where no " +
+                    "condition is established. Required once a being states an appearance; a " +
+                    "single word outside a list is an error. See " +
                     "[a being's look](format-details.md#a-beings-look) for what each word means.",
-                entries: Object.freeze({
-                    kind: "string",
-                    shape: "a string",
-                    allowed: lookValues("appearance.complexion"),
-                }),
             },
             {
                 name: "appearance.extra_features",
                 ...TEXT_LIST,
-                describe: "Anything else a stranger would notice, in free text.",
+                check: (note) => checkExtraFeatures(note, BEING_LOOK_VOCABULARY),
+                describe:
+                    "The visible physical marks no word covers, each a short plain description " +
+                    "of one: `a burn scar on the left forearm`, `a missing finger`. An entry " +
+                    "stating a hair, eye or skin colour or a skin condition, gear or clothing, a " +
+                    "voice, behaviour or manner, an impression, handedness, sterility or an " +
+                    "apparent age is an error, as is any punctuation but a hyphen or apostrophe " +
+                    "inside a word. See [a being's look](format-details.md#a-beings-look).",
             },
         ]),
     }),
@@ -2001,6 +2010,15 @@ export const NOTE_VOCABULARY = Object.freeze({
         ],
         data: Object.freeze([
             ...CALENDAR_FIELDS,
+            {
+                name: "parents",
+                ...LINKS,
+                ref: "lore",
+                accepts: ["lore"],
+                check: checkCultureParents,
+                describe:
+                    "Culture only: parent culture lore notes, searched in listed depth-first order for omitted language and appearance profile fields.",
+            },
             {
                 ...CULTURE_FIELD,
                 describe:

package/engine/npc-generate.mjs

@@ -40,7 +40,8 @@
  *   being in the package already holds it.
  * - `type: being`, `subType: npc`, `tags: [generated, draft]`.
  * - `frame`, and `appearance.eye_color`, `hair_color`, `skin_color` and
- *   `complexion` — weighted draws from the culture's appearance profile.
+ *   `complexion` — weighted draws from the culture's appearance profile;
+ *   `complexion` is a list of the one word drawn.
  * - `height` — from the profile's range for the gender, in feet and inches.
  * - `weight` — from the height and the frame's body-mass band, in pounds.
  * - `born` — an adult age of {@link ADULT_AGE} years before the package's
@@ -346,8 +347,7 @@ export function appearanceParagraph({ name, age, gender, height, frame, appearan
     const sentences = [`${first}.`];
 
     const look = appearance ?? {};
-    const complexion = [look.complexion ?? []]
-        .flat()
+    const complexion = (Array.isArray(look.complexion) ? look.complexion : [])
         .filter(Boolean)
         .map((w) => wordLabel("appearance.complexion", w));
     const parts = [
@@ -491,7 +491,8 @@ export function generateNpc(spec, context) {
     const appearance = { ...look };
     for (const key of profileLookKeys(BEING_LOOK_VOCABULARY)) {
         if (key === "frame" || given(look[key])) continue;
-        appearance[key] = weighted(profile[key], draw(`data.appearance.${key}`));
+        const word = weighted(profile[key], draw(`data.appearance.${key}`));
+        appearance[key] = key === "complexion" ? [word] : word;
     }
     if (!given(look.extra_features)) appearance.extra_features = [];
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "23.3.1",
+    "version": "23.4.0",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",
@@ -191,8 +191,9 @@
         "build:asset-index": "node ci/emit-asset-index.mjs",
         "format": "prettier --write .",
         "format:check": "prettier --check .",
-        "lint": "run-p --aggregate-output -c --max-parallel 4 format:check lint:markdown lint:yaml lint:labels lint:image-roles lint:banners lint:content-format",
+        "lint": "run-p --aggregate-output -c --max-parallel 4 format:check lint:markdown lint:yaml lint:labels lint:image-roles lint:banners lint:content-format lint:docs-links",
         "lint:markdown": "node bin/package-build.mjs markdown",
+        "lint:docs-links": "node bin/package-build.mjs docs links",
         "lint:yaml": "node bin/package-build.mjs yaml",
         "lint:labels": "node bin/package-build.mjs labels check",
         "lint:image-roles": "vitest run tests/theme-image-roles.test.ts",