@heroiclands/package-build 23.12.8 → 24.0.0

package/engine/word-forms.mjs

@@ -0,0 +1,364 @@
+/*
+ * 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 regular forms a language's own rules derive from its lexicon.** Each
+ * rule a language note states in machine-readable form gives a lexicon word
+ * further forms, and nothing else does:
+ *
+ * - **the noun plural**: `data.grammar.plural`, or the word's own `plural`;
+ * - **the verb pattern**: a verb's citation form with one ending of
+ *   `data.grammar.verbs.persons`, which takes the place of a closing
+ *   `data.grammar.verbs.replaces` where the pattern states one (see
+ *   {@link module:engine/verb-pattern.verbForm});
+ * - **a replacing suffix**: a suffix of `data.affixes` that states `replaces`,
+ *   or its `front` form, on a word whose class base its `attachesTo` names,
+ *   or on any word where it states none: `vowel` takes the place of a closing
+ *   vowel (a letter whose base is `a`, `e`, `i`, `o` or `u`), letters take the
+ *   place of those letters, and a stem closing otherwise takes the suffix
+ *   whole. An affix that states no `replaces` derives nothing here;
+ * - **agreement**: a word whose class base `data.grammar.agreement.classes`
+ *   names, closing on one of `data.grammar.agreement.endings` (the longest
+ *   that leaves a stem), also takes each other ending in its place, and each
+ *   of those forms and the word itself takes the plural the
+ *   `data.grammar.plural` rule gives;
+ * - **participles**: a verb closing on one of `data.grammar.participles.root`
+ *   (the longest that leaves a root) drops it, and each suffix of `data.affixes`
+ *   that `data.grammar.participles.affixes` names, by its `form`, attaches to
+ *   the root as its `replaces` says, or whole where it states none. A
+ *   participle closing on an agreement ending agrees.
+ *
+ * A word's `variants` are known forms as written, and each takes the rules
+ * its word takes: the plural rule, the verb pattern, the suffixes, agreement
+ * and participles. A word's own stated `plural` belongs to its citation form
+ * alone.
+ *
+ * The mapped-run word check ({@link module:engine/run-words}) and
+ * `package-build lexicon --derived` both read {@link derivedForms}, so what
+ * the command lists is what the check accepts.
+ *
+ * @module
+ */
+
+import { pluralByRule, pluralOf } from "./dictionary-rows.mjs";
+import { replaceClosing, verbForm, verbPattern } from "./verb-pattern.mjs";
+import { parseWordClass } from "./word-classes.mjs";
+import { WORD } from "./word-pattern.mjs";
+
+/** Whether a value is a plain map. */
+const isMap = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+/** A list value, or an empty one. */
+const listOf = (value) => (Array.isArray(value) ? value : []);
+
+/** The characters a compound is split at. */
+const JOINS = /[–-]/u;
+
+/**
+ * A word as it is compared: NFC, lowercase, `’` read as `'`.
+ *
+ * @param {string} word - The word.
+ * @returns {string} Its folded form.
+ */
+export function foldWord(word) {
+    return word.normalize("NFC").toLowerCase().replace(/’/gu, "'");
+}
+
+/** Whether a character is a vowel: its base letter is a, e, i, o or u. */
+const isVowel = (char) => /^[aeiou]/iu.test(char.normalize("NFD"));
+
+/**
+ * Add a text's words to a set, each whole and each part of a compound.
+ *
+ * @param {Set<string>} set - The set.
+ * @param {string} text - A form or a name.
+ */
+export function addWords(set, text) {
+    for (const [word] of text.matchAll(WORD)) {
+        const folded = foldWord(word);
+        set.add(folded);
+        for (const part of folded.split(JOINS)) if (part) set.add(part);
+    }
+}
+
+/**
+ * The form a suffix makes of a stem.
+ *
+ * @param {string} stem - The stem, folded.
+ * @param {string} suffix - The suffix, folded, with no hyphen.
+ * @param {string|undefined} replaces - The affix's `replaces`; none adds the
+ *   suffix whole.
+ * @returns {string} The derived form.
+ */
+function attach(stem, suffix, replaces) {
+    if (replaces === "vowel") {
+        const last = Array.from(stem).at(-1);
+        return last !== undefined && isVowel(last) ?
+                stem.slice(0, -last.length) + suffix
+            :   stem + suffix;
+    }
+    return replaceClosing(stem, suffix, replaces === undefined ? undefined : foldWord(replaces));
+}
+
+/**
+ * An affix's suffixes: its `form` and its `front` form, each written `-x`,
+ * folded and without the hyphen.
+ *
+ * @param {Record<string, any>} affix - One `data.affixes` entry.
+ * @returns {string[]} The suffixes.
+ */
+function suffixesOf(affix) {
+    const out = [];
+    for (const written of [affix.form, affix.front]) {
+        if (typeof written !== "string") continue;
+        const form = foldWord(written.trim());
+        if (!/^[-–]/u.test(form) || /[-–]$/u.test(form)) continue;
+        const suffix = form.replace(/^[-–]+/u, "");
+        if (suffix) out.push(suffix);
+    }
+    return out;
+}
+
+/**
+ * The suffixes a language's affixes state `replaces` for, each with the class
+ * bases its `attachesTo` names.
+ *
+ * @param {Record<string, any>} data - The language note's `data`.
+ * @returns {Array<{suffix: string, replaces: string, classes: ReadonlySet<string>|undefined}>}
+ *   The suffixes, folded; `classes` is `undefined` where the affix attaches to
+ *   every class.
+ */
+function replacingSuffixes(data) {
+    const out = [];
+    for (const affix of listOf(data.affixes)) {
+        if (!isMap(affix) || typeof affix.replaces !== "string") continue;
+        const classes =
+            Array.isArray(affix.attachesTo) ?
+                new Set(
+                    affix.attachesTo
+                        .filter((item) => typeof item === "string")
+                        .map((item) => item.trim()),
+                )
+            :   undefined;
+        for (const suffix of suffixesOf(affix))
+            out.push({ suffix, replaces: affix.replaces, classes });
+    }
+    return out;
+}
+
+/**
+ * The strings of a list, trimmed and folded, keeping those with letters.
+ *
+ * @param {unknown} value - The list.
+ * @returns {string[]} The strings.
+ */
+const foldedStrings = (value) =>
+    listOf(value)
+        .filter((item) => typeof item === "string" && item.trim())
+        .map((item) => foldWord(item.trim()));
+
+/**
+ * A language's agreement rule, as derivation reads it.
+ *
+ * @typedef {object} Agreement
+ * @property {ReadonlySet<string>} classes - The class bases that agree.
+ * @property {readonly string[]} endings - The endings, folded, longest first.
+ */
+
+/**
+ * Read a language's `data.grammar.agreement`.
+ *
+ * @param {unknown} value - The authored value.
+ * @returns {Agreement|undefined} The rule, or `undefined` where none is stated
+ *   in full.
+ */
+function agreementOf(value) {
+    if (!isMap(value)) return undefined;
+    const classes = listOf(value.classes).filter((item) => typeof item === "string");
+    const endings = [
+        ...new Set(
+            listOf(value.endings)
+                .filter((item) => typeof item === "string")
+                .map((item) => foldWord(item.trim())),
+        ),
+    ];
+    if (!classes.length || endings.length < 2) return undefined;
+    return {
+        classes: new Set(classes.map((item) => item.trim())),
+        endings: endings.sort((a, b) => b.length - a.length),
+    };
+}
+
+/**
+ * The forms an agreeing word takes beside its own.
+ *
+ * @param {string} form - The word, folded.
+ * @param {Agreement} agreement - The rule.
+ * @param {Record<string, any>|undefined} grammar - The language's grammar,
+ *   for its plural rule.
+ * @returns {string[]} The forms; none where the word closes on no ending.
+ */
+function agreeingForms(form, agreement, grammar) {
+    const ending = agreement.endings.find((one) => form.length > one.length && form.endsWith(one));
+    if (ending === undefined) return [];
+    const stem = form.slice(0, form.length - ending.length);
+    const singulars = agreement.endings.map((one) => stem + one);
+    const out = singulars.filter((one) => one !== form);
+    for (const one of singulars) {
+        const plural = pluralByRule(one, grammar);
+        if (plural) out.push(foldWord(plural));
+    }
+    return out;
+}
+
+/**
+ * A language's participle rule, as derivation reads it.
+ *
+ * @typedef {object} Participles
+ * @property {readonly string[]} root - The root endings, folded, longest
+ *   first.
+ * @property {Array<{suffix: string, replaces: string|undefined}>} suffixes -
+ *   The participle suffixes, folded.
+ */
+
+/**
+ * Read a language's `data.grammar.participles` against its affixes.
+ *
+ * @param {unknown} value - The authored value.
+ * @param {Record<string, any>} data - The language note's `data`.
+ * @returns {Participles|undefined} The rule, or `undefined` where it names no
+ *   root ending or no suffix the affixes state.
+ */
+function participlesOf(value, data) {
+    if (!isMap(value)) return undefined;
+    const root = [...new Set(foldedStrings(value.root))].sort((a, b) => b.length - a.length);
+    const named = new Set(
+        listOf(value.affixes)
+            .filter((item) => typeof item === "string")
+            .map((item) => item.trim()),
+    );
+    const suffixes = [];
+    for (const affix of listOf(data.affixes)) {
+        if (!isMap(affix) || typeof affix.form !== "string" || !named.has(affix.form.trim()))
+            continue;
+        const replaces = typeof affix.replaces === "string" ? affix.replaces : undefined;
+        for (const suffix of suffixesOf(affix)) suffixes.push({ suffix, replaces });
+    }
+    if (!root.length || !suffixes.length) return undefined;
+    return { root, suffixes };
+}
+
+/**
+ * The participles of a verb.
+ *
+ * @param {string} citation - The citation form, folded.
+ * @param {Participles} participles - The rule.
+ * @returns {string[]} The participles; none where the verb closes on no root
+ *   ending.
+ */
+function participleForms(citation, participles) {
+    const ending = participles.root.find(
+        (one) => citation.length > one.length && citation.endsWith(one),
+    );
+    if (ending === undefined) return [];
+    const root = citation.slice(0, citation.length - ending.length);
+    return participles.suffixes.map(({ suffix, replaces }) => attach(root, suffix, replaces));
+}
+
+/**
+ * One form a rule derives from a lexicon word.
+ *
+ * @typedef {object} DerivedForm
+ * @property {string} form - The form, folded.
+ * @property {Record<string, any>} word - The `data.words` entry it comes from.
+ */
+
+/**
+ * Every form the language's rules derive from its lexicon words, and each
+ * declared variant of a word, in `data.words` order, each once, leaving out a
+ * form that is a lexicon word.
+ *
+ * @param {Record<string, any>|undefined} data - The language note's `data`.
+ * @returns {DerivedForm[]} The forms.
+ */
+export function derivedForms(data) {
+    const words = listOf(data?.words).filter(
+        (word) => isMap(word) && typeof word.form === "string",
+    );
+    const grammar = isMap(data?.grammar) ? data.grammar : undefined;
+    const verbs = verbPattern(grammar?.verbs);
+    const replaces = verbs?.replaces === undefined ? undefined : foldWord(verbs.replaces);
+    const suffixes = replacingSuffixes(data ?? {});
+    const agreement = agreementOf(grammar?.agreement);
+    const participles = participlesOf(grammar?.participles, data ?? {});
+    const seen = new Set(words.map((word) => foldWord(word.form)));
+    const out = [];
+    for (const word of words) {
+        const add = (form) => {
+            const folded = foldWord(form);
+            if (!folded || seen.has(folded)) return;
+            seen.add(folded);
+            out.push({ form: folded, word });
+        };
+        const base = parseWordClass(word.class).base;
+        const variants = listOf(word.variants).filter(
+            (variant) => typeof variant === "string" && variant.trim() !== "",
+        );
+        for (const [at, written] of [word.form, ...variants].entries()) {
+            const folded = foldWord(written);
+            if (at > 0) add(written);
+            const plural =
+                at === 0 ? pluralOf(word, grammar)
+                : base === "n" ? pluralByRule(written, grammar)
+                : null;
+            if (plural) add(plural);
+            if (verbs && base === "v")
+                for (const { ending } of verbs.endings)
+                    add(verbForm(folded, foldWord(ending), replaces));
+            const attaching = suffixes.filter(
+                ({ classes }) => classes === undefined || (base !== undefined && classes.has(base)),
+            );
+            if (attaching.length)
+                for (const [stem] of written.matchAll(WORD)) {
+                    const one = foldWord(stem);
+                    for (const { suffix, replaces: closing } of attaching)
+                        add(attach(one, suffix, closing));
+                }
+            if (agreement && base !== undefined && agreement.classes.has(base))
+                for (const form of agreeingForms(folded, agreement, grammar)) add(form);
+            if (participles && base === "v")
+                for (const participle of participleForms(folded, participles)) {
+                    add(participle);
+                    if (agreement)
+                        for (const form of agreeingForms(participle, agreement, grammar)) add(form);
+                }
+        }
+    }
+    return out;
+}
+
+/**
+ * The words a language note accepts of its own: its forms, and what its rules
+ * derive from them (see {@link derivedForms}), each whole and each part of a
+ * compound.
+ *
+ * @param {Record<string, any>} data - The language note's `data`.
+ * @returns {Set<string>} The words, folded.
+ */
+export function lexiconWords(data) {
+    const accepted = new Set();
+    for (const word of listOf(data?.words))
+        if (isMap(word) && typeof word.form === "string") addWords(accepted, word.form);
+    for (const { form } of derivedForms(data)) addWords(accepted, form);
+    return accepted;
+}

package/engine/word-rows.mjs

@@ -69,8 +69,18 @@ export const WORD_COLUMNS = Object.freeze([
 /** Every column of the `glossary` relation, in order. */
 export const GLOSSARY_COLUMNS = Object.freeze(["note", "position", ...GLOSSARY_ENTRY_KEYS]);
 
+/**
+ * The affix's own keys an affix row carries: all but `native`, its writings
+ * under a logographic map, which `package-build lexicon` resolves.
+ */
+const AFFIX_ROW_KEYS = Object.freeze(AFFIX_KEYS.filter((key) => key !== "native"));
+
 /** Every column of the `affixes` relation, in order. */
-export const AFFIX_COLUMNS = Object.freeze([...WORD_IDENTITY_COLUMNS, ...AFFIX_KEYS, "written"]);
+export const AFFIX_COLUMNS = Object.freeze([
+    ...WORD_IDENTITY_COLUMNS,
+    ...AFFIX_ROW_KEYS,
+    "written",
+]);
 
 /** Every column of the `fields` relation, in order. */
 export const FIELD_COLUMNS = Object.freeze([...WORD_IDENTITY_COLUMNS, ...FIELD_KEYS]);
@@ -322,7 +332,7 @@ function languageListRows(records, list, keys) {
  * @returns {object[]} One row per affix, in record then entry order.
  */
 export function affixRows(records) {
-    return languageListRows(records, "affixes", AFFIX_KEYS).map((row) => ({
+    return languageListRows(records, "affixes", AFFIX_ROW_KEYS).map((row) => ({
         ...row,
         written: row.zero === true ? ZERO_AFFIX : row.form,
     }));

package/engine/word-terms.mjs

@@ -126,7 +126,8 @@ export const WORD_NATIVE_FIELDS = Object.freeze([
         required: true,
         shape: "the word in the script, as the map's characters",
         describe:
-            "The word as the script writes it, where the map's rows would write it otherwise.",
+            "The word as the script writes it, where the map's rows would write it otherwise, " +
+            "or as a logographic map writes it.",
     }),
 ]);
 
@@ -150,7 +151,7 @@ export const WORD_FIELDS = Object.freeze([
         entries: Object.freeze({ kind: "string", shape: "a form, bare" }),
         describe:
             "The word's other forms, such as a long form beside a short one; a marked use of " +
-            "one cites the word.",
+            "one cites the word, and a mapped run accepts it and the forms the language's rules derive from it.",
     }),
     Object.freeze({
         name: "name_sort",
@@ -191,6 +192,15 @@ export const WORD_FIELDS = Object.freeze([
         describe:
             "The meaning, in brief; a list states one sense per entry, which a dictionary numbers.",
     }),
+    Object.freeze({
+        name: "concept",
+        kind: "string-or-list",
+        shape: "a core concept's id, or a list of them",
+        entries: Object.freeze({ kind: "string", shape: "a core concept's id" }),
+        describe:
+            "The core concepts the word serves, each an `id` of a `data.concepts` list. The " +
+            "core report counts the word toward them.",
+    }),
     Object.freeze({
         name: "source",
         kind: "map",
@@ -250,8 +260,10 @@ export const WORD_FIELDS = Object.freeze([
             fields: WORD_NATIVE_FIELDS,
         }),
         describe:
-            "The word's native form under a map, stated only where the map's rows spell it " +
-            "differently. Its derived forms are spelled by the rows.",
+            "The word's native form under a map. Under a map that spells by its rows it is " +
+            "stated only where the rows spell the word differently, and the word's derived " +
+            "forms are spelled by the rows; under a logographic map it is the word's writing, " +
+            "which its derived forms and the words built on it are written from.",
     }),
 ]);
 
@@ -368,6 +380,15 @@ export const AFFIX_FIELDS = Object.freeze([
             "What it takes the place of at the close of the stem: `vowel` for any closing " +
             "vowel, or the letters it replaces; added to the whole stem where absent.",
     }),
+    Object.freeze({
+        name: "attachesTo",
+        kind: "list",
+        shape: "a list of word classes, such as `[n, adj]`",
+        entries: Object.freeze({ kind: "string", shape: "a word class, such as `n`" }),
+        describe:
+            "The word classes it attaches to, by their base; every class where absent. A " +
+            "suffix stating `replaces` derives forms of these classes' words alone.",
+    }),
     Object.freeze({
         name: "lengthens",
         kind: "boolean",
@@ -402,6 +423,19 @@ export const AFFIX_FIELDS = Object.freeze([
         shape: "a tone pattern, such as `L`",
         describe: "The tone pattern the affix carries, written as a word's `tones` is.",
     }),
+    Object.freeze({
+        name: "native",
+        kind: "list",
+        shape: "a list of `{ map, font?, text }`",
+        entries: Object.freeze({
+            kind: "map",
+            shape: "a map — `{ map, font?, text }`",
+            fields: WORD_NATIVE_FIELDS,
+        }),
+        describe:
+            "The affix's writing under a logographic map, which a word whose `built` names the " +
+            "affix is written with.",
+    }),
 ]);
 
 /** The keys of {@link WORD_FIELD_FIELDS}, in declared order. */

package/manifest.mjs

@@ -121,10 +121,9 @@ export const HOMEPAGE_ORIGIN = "https://www.heroiclands.org";
  * to drift — and the one that drifts is this one, because nothing fetches `url`
  * the way Foundry fetches `manifest`, so a wrong value is never reported.
  *
- * The site's own `baseURL` says the same thing, and is deliberately not the
- * source: it sits at `site/hugo.toml` in most repositories and `kb/hugo.toml`
- * in the system, so reading it would mean the packaging half knowing where each
- * repository keeps its site configuration.
+ * `package.json`'s `homepage` says the same thing, and is deliberately not the
+ * source: reading it would mean the packaging half depending on the site's
+ * configuration.
  *
  * @param {string} contentPackage - The package's content-package name.
  * @returns {string} The homepage URL, with its trailing slash.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "23.12.8",
+    "version": "24.0.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",
@@ -123,17 +123,18 @@
         "engine",
         "githooks",
         "hm3",
-        "hugo-theme",
         "index.mjs",
         "lang.mjs",
         "manifest.mjs",
         "markdownlint-config.mjs",
         "prettier-config.mjs",
         "release.mjs",
+        "site-theme",
         "sohl",
         "stage.mjs",
         "templates.mjs",
-        "types"
+        "types",
+        "vendor"
     ],
     "dependencies": {
         "@duckdb/node-api": "^1.5.5-r.4",
@@ -151,16 +152,16 @@
         "fflate": "^0.8.3",
         "flesch": "^2.0.1",
         "glob": "^13.0.6",
-        "gray-matter": "^4.0.3",
         "handlebars": "^4.7.10",
+        "highlight.js": "^11.12.0",
         "ignore": "^7.0.12",
+        "js-yaml": "^5.5.0",
         "jsonc-parser": "^3.3.1",
         "loglevel": "^1.9.2",
         "loglevel-plugin-prefix": "^0.8.4",
         "markdown-it": "^15.0.0",
         "markdown-it-deflist": "^4.0.0",
         "markdown-it-footnote": "^4.0.0",
-        "markdownlint": "^0.42.0",
         "minimatch": "^10.2.6",
         "pagefind": "^1.5.2",
         "prettier": "^3.9.6",
@@ -173,7 +174,6 @@
         "retext-simplify": "^8.0.0",
         "retext-stringify": "^4.0.0",
         "sharp": "^0.35.4",
-        "smol-toml": "^1.8.0",
         "ssh2-sftp-client": "^12.1.1",
         "syllable": "^5.0.1",
         "typescript": "^6.0.3",
@@ -185,6 +185,8 @@
     "devDependencies": {
         "@changesets/cli": "^3.0.0",
         "@types/node": "^26.2.0",
+        "esbuild": "^0.28.2",
+        "markdownlint": "^0.42.0",
         "npm-run-all": "^4.1.5",
         "vitest": "^5.0.0"
     },
@@ -193,7 +195,8 @@
         "test:watch": "vitest",
         "build": "node bin/package-build.mjs ci",
         "deploy:npm": "node ci/publish-npm.mjs",
-        "prepack": "run-s build:types build:asset-index",
+        "prepack": "run-s build:vendor build:types build:asset-index",
+        "build:vendor": "node scripts/vendor-markdownlint.mjs",
         "build:types": "tsc -p tsconfig.dts.json",
         "build:asset-index": "node ci/emit-asset-index.mjs",
         "format": "node ci/prettier.mjs --write",
@@ -210,7 +213,7 @@
         "lint:content-format:fields": "node bin/package-build.mjs content-format fields --fields sohl && node bin/package-build.mjs content-format fields --fields hm3",
         "changeset": "changeset",
         "changeset:version": "changeset version && node bin/package-build.mjs changelog group && npm install --package-lock-only",
-        "prepare": "git config core.hooksPath .githooks || true",
+        "prepare": "(git config core.hooksPath .githooks || true) && (test ! -e scripts/vendor-markdownlint.mjs || npm run build:vendor)",
         "build:deps": "node bin/package-build.mjs deps fetch"
     },
     "engines": {

package/{hugo-theme → site-theme}/data/banners.yaml

@@ -1,16 +1,16 @@
 # Which banner images exist in the shared artwork set.
 #
-# `partials/hero-banner.html` resolves a page's hero image to a path under
+# The hero banner resolves a page's hero image to a path under
 # `images/banners/`, and that path is emitted into a `background-image` with no
 # way to test it: the artwork is served from the consuming site's
-# `params.cdnBaseURL`, and Hugo cannot ask a remote host whether a URL exists.
-# So a banner that was never drawn would 404 in silence — the band renders
-# with its title, palette and gradient intact and a dead image URL behind it,
-# and nothing fails: not the build, not Hugo, not the deploy guard.
+# `params.cdnBaseURL`, and the build cannot ask a remote host whether a URL
+# exists. So a banner that was never drawn would 404 in silence — the band
+# renders with its title, palette and gradient intact and a dead image URL
+# behind it, and nothing fails: not the build, not the deploy guard.
 #
 # This file is the declaration that replaces that missing test. A name listed
 # here is asserted to exist; a resolved banner whose name is absent falls back
-# to `default.webp` and Hugo warns once for it during the consumer's build.
+# to `default.webp` and the build warns once for it.
 #
 # It speaks for the names this theme resolves itself — a hand-authored
 # `banner:` and the subtype defaults below. A note's own `data.banner` arrives
@@ -21,10 +21,6 @@
 # (`ci/check-banners.mjs`, part of `npm run lint`) fetches every name below
 # from a real asset host and fails on any non-200. Add a name here only after
 # the file is published, or the check will say so.
-#
-# A consumer publishing its own artwork set overrides the whole list by
-# shipping its own `data/banners.yaml` — Hugo reads the site's data directory
-# in preference to the theme's.
 
 # The asset root every name below is resolved under, and the name used when a
 # resolved banner is not in `available`. Both are relative to the consuming

package/site-theme/layouts/base.hbs

@@ -0,0 +1,31 @@
+{{!-- SPDX-License-Identifier: GPL-3.0-or-later --}}
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>{{head.title}}</title>
+  <meta name="description" content="{{head.description}}">
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Cinzel:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&family=Lora:ital,wght@0,400;0,500;0,600;0,700;1,400;1,500;1,600&display=swap" rel="stylesheet">
+  <link rel="stylesheet" href="{{site.urls.style}}">
+  {{#if site.urls.scriptFonts}}
+  <link rel="stylesheet" href="{{site.urls.scriptFonts}}">
+  {{/if}}
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/7.3.1/css/all.min.css" crossorigin="anonymous" referrerpolicy="no-referrer">
+  <link rel="stylesheet" href="{{site.urls.icons}}">
+  <link rel="stylesheet" href="{{site.urls.code}}">
+  {{#if site.feed}}
+  <link rel="alternate" type="application/atom+xml" title="{{site.feed.title}}" href="{{site.feed.url}}">
+  {{/if}}
+</head>
+<body>
+  {{> header site}}
+  <main>
+    {{{body}}}
+  </main>
+  {{> footer site}}
+  {{> copy-buttons}}
+</body>
+</html>

package/site-theme/layouts/blog-list.hbs

@@ -0,0 +1,30 @@
+{{!-- SPDX-License-Identifier: GPL-3.0-or-later --}}
+{{#if hero}}
+{{> hero-banner hero}}
+{{/if}}
+<article class="single">
+  <div class="single-content">
+    {{#if body}}
+    <div class="single-body">
+      {{{body}}}
+    </div>
+    {{/if}}
+    {{#if posts}}
+    <ul class="blog-list">
+      {{#each posts}}
+      <li class="blog-list-item">
+        {{#if date}}
+        <time class="blog-list-date" datetime="{{date.iso}}">{{date.text}}</time>
+        {{/if}}
+        <a class="blog-list-title" href="{{url}}">{{title}}</a>
+        {{#if preview}}
+        <p class="blog-list-desc">{{preview}}</p>
+        {{/if}}
+      </li>
+      {{/each}}
+    </ul>
+    {{else}}
+    <p class="page-list-empty">No posts yet.</p>
+    {{/if}}
+  </div>
+</article>