@heroiclands/package-build 22.27.0 → 23.0.0

package/engine/literature-notes.mjs

@@ -0,0 +1,133 @@
+/*
+ * 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 work a people tells, sings or writes: the `literature` lore subType and the
+ * four optional facts such a note may state about itself.
+ *
+ * `DataFieldSpec` declares the keys a type accepts, not the subType that may
+ * write them, so {@link checkLiteratureNote} scopes these keys to `literature`
+ * the way the calendar check scopes its own to `calendar`.
+ *
+ * @module
+ */
+
+import { isAddressTuple, parseAddress, renderAddress } from "./address.mjs";
+import { checkCultureChoice } from "./culture-choice.mjs";
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+
+/** The `lore` subType whose notes are works of literature. */
+export const LITERATURE_SUBTYPE = "literature";
+
+/**
+ * Require `data.language` to address a `skill` note whose subType is
+ * `language`.
+ *
+ * An Address that does not resolve is the reference check's to report, so
+ * this speaks only about a target that exists and is the wrong kind.
+ *
+ * @param {object} note
+ * @param {{index?: object}} [options]
+ * @returns {object[]} The findings.
+ */
+export function checkLanguageChoice(note, { index } = {}) {
+    const value = note.fm?.data?.language;
+    if (value === undefined || value === null || !index?.addressHit) return [];
+    const tuple = parseAddress(value, {
+        package: index.contentPackage,
+        system: "note",
+        type: "skill",
+        types: index.types,
+        packages: index.packages,
+    });
+    if (tuple.reason) return [];
+    const target = index.addressHit(renderAddress(tuple));
+    if (!target) return [];
+    const fm = target.fm ?? target;
+    if (tuple.type === "skill" && fm.subType === "language") return [];
+    return [
+        {
+            file: note.file,
+            ...positionOfFrontmatterPath(note.raw ?? "", ["data", "language"]),
+            severity: "error",
+            message: `data.language ${isAddressTuple(value) ? renderAddress(value) : value} names a note that is not a skill whose subType is language`,
+        },
+    ];
+}
+
+/**
+ * The fields a `literature` note may state. Every one is optional.
+ *
+ * @type {ReadonlyArray<object>}
+ */
+export const LITERATURE_FIELDS = Object.freeze([
+    {
+        name: "culture",
+        shape: "an Address",
+        kind: "address",
+        ref: "lore",
+        accepts: ["lore"],
+        check: checkCultureChoice,
+        describe: "The people whose work this is, as a culture lore note.",
+    },
+    {
+        name: "form",
+        shape: "string",
+        kind: "string",
+        describe:
+            "The kind of work in its people's own terms — an epic, a saga, a " +
+            "praise-song, an elegy. Free text.",
+    },
+    {
+        name: "subjects",
+        shape: "list of Addresses",
+        kind: "list",
+        entryKind: "address",
+        describe: "The beings, places, gods, events and other notes the work concerns.",
+    },
+    {
+        name: "language",
+        shape: "an Address",
+        kind: "address",
+        ref: "skill",
+        accepts: ["skill"],
+        check: checkLanguageChoice,
+        describe: "The tongue the work is composed in, as a language skill note.",
+    },
+]);
+
+const LITERATURE_KEYS = Object.freeze(LITERATURE_FIELDS.map((field) => field.name));
+
+/**
+ * Refuse a literature field on a lore note of any other subType.
+ *
+ * @param {object} note
+ * @returns {object[]} One error per literature key written off `literature`.
+ */
+export function checkLiteratureNote(note) {
+    const type = String(note?.type ?? note?.fm?.type ?? "").toLowerCase();
+    const subType = String(note?.fm?.subType ?? "").toLowerCase();
+    if (type !== "lore" || subType === LITERATURE_SUBTYPE) return [];
+    const data = note?.fm?.data;
+    if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+    return LITERATURE_KEYS.filter((key) => data[key] !== undefined && data[key] !== null).map(
+        (key) => ({
+            file: note.file,
+            ...positionOfFrontmatterPath(note.raw ?? "", ["data", key], { key: true }),
+            severity: "error",
+            message:
+                `\`data.${key}\` describes a work of literature, and this note's ` +
+                `\`subType\` is not \`literature\``,
+        }),
+    );
+}

package/engine/literature-works.mjs

@@ -0,0 +1,153 @@
+/*
+ * 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 works of literature that concern each page, derived from what the works
+ * say. A `literature` lore note names its subjects in `data.subjects`; the site
+ * build inverts that into a `works` list on every subject's page, so a reader on
+ * a hero's, a place's or a god's page reaches the epics and legends about it.
+ * The subject note writes nothing.
+ *
+ * A work in a fetched index lists on this package's subject pages when that
+ * index carries its `subjects`. A subject in another package has no page here,
+ * so a local work naming one lists nowhere.
+ *
+ * @module
+ */
+
+import { parseAddress, renderAddress } from "./address.mjs";
+import { readCanonicalKey } from "./content-address.mjs";
+import { LITERATURE_SUBTYPE } from "./literature-notes.mjs";
+
+/** The page front-matter key the site build writes. */
+export const WORKS_KEY = "works";
+
+/** @typedef {{title: string, url?: string, form?: string}} WorkEntry */
+/**
+ * @typedef {object} WorksNode
+ * @property {string} key Own Address, normalized to the `note` system.
+ * @property {string} title
+ * @property {string} [url] Absent for a note that publishes no page.
+ * @property {string} [package] Owning content package.
+ * @property {string} [form] A work's `data.form`.
+ * @property {unknown[]} subjects A work's `data.subjects`; empty for any other note.
+ */
+
+/** The note-system key of one Address, or "" where it names nothing. */
+function addressKey(value, pkg, types) {
+    if (value == null) return "";
+    const tuple = parseAddress(value, { package: pkg ?? "local", system: "note", types });
+    if (tuple.reason) return "";
+    return renderAddress({ ...tuple, system: "note" }).toLowerCase();
+}
+
+/** Whether a note is a work of literature. */
+function isWork(type, subType) {
+    return type === "lore" && String(subType ?? "").toLowerCase() === LITERATURE_SUBTYPE;
+}
+
+/**
+ * One local page's node.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {{title: string, url?: string, package?: string}} page
+ * @returns {WorksNode|null} Null for a note with no type or shortcode.
+ */
+export function worksNode(fm, { title, url, package: pkg }) {
+    const type = String(fm?.type ?? "");
+    const shortcode = String(fm?.shortcode ?? "").toLowerCase();
+    if (!type || !shortcode) return null;
+    const data = fm.data && typeof fm.data === "object" && !Array.isArray(fm.data) ? fm.data : {};
+    const work = isWork(type, fm.subType);
+    return {
+        key: renderAddress({ package: pkg ?? "local", system: "note", type, shortcode }),
+        title,
+        ...(url ? { url } : {}),
+        ...(pkg ? { package: pkg } : {}),
+        ...(work && typeof data.form === "string" && data.form ? { form: data.form } : {}),
+        subjects:
+            !work ? []
+            : Array.isArray(data.subjects) ? data.subjects
+            : data.subjects ? [data.subjects]
+            : [],
+    };
+}
+
+/**
+ * The works a fetched index carries, as nodes. Only a work can list itself on
+ * a page, and only a page of this package can carry the list, so a foreign
+ * entry that is not a work is never needed here.
+ *
+ * @param {Map<string, object>|undefined} foreignIndex
+ * @returns {WorksNode[]}
+ */
+export function foreignWorksNodes(foreignIndex) {
+    const out = [];
+    for (const [canonical, entry] of foreignIndex ?? []) {
+        const tuple = readCanonicalKey(canonical);
+        if (!tuple || !isWork(entry?.type, entry?.subType)) continue;
+        if (!Array.isArray(entry.subjects) || !entry.subjects.length) continue;
+        out.push({
+            key: renderAddress({ ...tuple, system: "note" }),
+            title: String(entry.name ?? tuple.shortcode),
+            ...(entry.url ? { url: entry.url } : {}),
+            package: tuple.package,
+            ...(typeof entry.form === "string" && entry.form ? { form: entry.form } : {}),
+            subjects: entry.subjects,
+        });
+    }
+    return out;
+}
+
+/**
+ * Invert every work's subjects into the list each subject's page carries.
+ *
+ * A subject is resolved in its work's own package. A work naming one subject
+ * twice lists once; a work naming itself is not listed on its own page.
+ * Entries sort by title.
+ *
+ * @param {Iterable<WorksNode|null>} nodes - Every local page, then any foreign work.
+ * @param {object} options
+ * @param {ReadonlySet<string>} options.types - Note types an Address may name.
+ * @returns {Map<string, {works: WorkEntry[]}>} Keyed by the subject page's URL.
+ */
+export function worksPages(nodes, { types }) {
+    const all = [...nodes].filter(Boolean);
+    /** @type {Map<string, WorksNode>} */
+    const pages = new Map();
+    for (const node of all) {
+        if (!node.url) continue;
+        const key = node.key.toLowerCase();
+        if (!pages.has(key)) pages.set(key, node);
+    }
+    /** @type {Map<string, {works: WorkEntry[]}>} */
+    const lists = new Map();
+    for (const work of all) {
+        const seen = new Set();
+        for (const subject of work.subjects) {
+            const target = pages.get(addressKey(subject, work.package, types));
+            if (!target || target.key === work.key || seen.has(target.url)) continue;
+            seen.add(target.url);
+            let block = lists.get(target.url);
+            if (!block) lists.set(target.url, (block = { works: [] }));
+            block.works.push({
+                title: work.title,
+                ...(work.url ? { url: work.url } : {}),
+                ...(work.form ? { form: work.form } : {}),
+            });
+        }
+    }
+    for (const block of lists.values())
+        block.works.sort((a, b) => a.title.localeCompare(b.title, "en"));
+    return lists;
+}

package/engine/metadata-index.mjs

@@ -437,6 +437,14 @@ export function loadForeignIndexes(config, localPackages, bases = PACKAGE_BASE)
                 ...(Object.hasOwn(record.data ?? {}, "government") ?
                     { government: record.data.government }
                 :   {}),
+                // What a work of literature concerns and what kind of work it
+                // is, so a consumer's subject pages list a dependency's works.
+                ...(parts.type === "lore" && record.subType === "literature" ?
+                    {
+                        subjects: record.data?.subjects ?? undefined,
+                        form: record.data?.form ?? undefined,
+                    }
+                :   {}),
                 package: pkg,
             });
             const entry = index.get(key);

package/engine/note-vocabulary.mjs

@@ -109,6 +109,7 @@ import { checkAffiliationRankFloor, checkRankLadder } from "./rank-ladder.mjs";
 import { checkCalendarChoice } from "./calendar-choice.mjs";
 import { checkLoreEvents } from "./lore-events.mjs";
 import { checkCultureChoice } from "./culture-choice.mjs";
+import { LITERATURE_FIELDS, checkLiteratureNote } from "./literature-notes.mjs";
 import { SOCIAL_TIES, SOCIAL_TIE_TARGET_TYPES } from "./social-tie-terms.mjs";
 import { parseNoteDate } from "./note-dates.mjs";
 import { reckoningContext } from "./reckoning-markers.mjs";
@@ -197,8 +198,8 @@ import { positionOfFrontmatterPath } from "./diagnostics.mjs";
  *
  * Two types answer **false**, and both are structural: a `folder` note's page
  * is a generated section index and a `homepage`'s is the site's front door, so
- * each is complete with no body at all. An empty body on one of them keeps its
- * address and resolves as `full`.
+ * an empty body on one of them keeps its address and resolves as `full`.
+ * This is classification only: author validation requires a body for every type.
  *
  * @typedef {object} TypeVocabulary
  * @property {readonly DataFieldSpec[]} data - The `data:` keys, closed.
@@ -1413,8 +1414,7 @@ export const NOTE_VOCABULARY = Object.freeze({
     // document, so its address carries the `none` system segment and
     // everything it says is a `data` property.
     //
-    // It carries **no prose**: a folder
-    // is structure, not content, so it wants no documentation journal and takes
+    // Its required body produces no documentation journal and takes
     // no part in `docEntryTypes`.
     folder: Object.freeze({
         stubbable: false,
@@ -1480,15 +1480,21 @@ export const NOTE_VOCABULARY = Object.freeze({
             "custom", // How a people practices a rite, observance, or usage.
             "bestiary", // A kind of creature that is not a people.
             "gathering", // A recurring public assembly, such as a fair or tournament.
+            "literature", // A work a people tells, sings, or writes, such as an epic or legend.
         ]),
         // A lore note is prose, and what it *is* about is its subType — with
-        // one exception. A calendar is a division of the year, and a division
-        // is data; the check scopes the family to the subType that means it,
-        // because `DataFieldSpec` declares the keys a type accepts and not the
-        // subType that may write them.
-        check: checkCalendarNote,
+        // two exceptions. A calendar is a division of the year, and a division
+        // is data; a work of literature states whose it is, in what tongue and
+        // about what. The checks scope each family to the subType that means
+        // it, because `DataFieldSpec` declares the keys a type accepts and not
+        // the subType that may write them.
+        check: (note, context) => [
+            ...checkCalendarNote(note, context),
+            ...checkLiteratureNote(note),
+        ],
         data: Object.freeze([
             ...CALENDAR_FIELDS,
+            ...LITERATURE_FIELDS,
             {
                 name: "events",
                 kind: "list",

package/engine/site-build.mjs

@@ -95,7 +95,7 @@ import { resolvedDateFields } from "./note-dates.mjs";
 import { isNoteRecord, noteFile } from "./index-records.mjs";
 // The one statement of what an empty body means, shared with the index.
 import { isStubNote } from "./note-state.mjs";
-import { isGmNote } from "./note-vocabulary.mjs";
+import { NOTE_VOCABULARY, isGmNote } from "./note-vocabulary.mjs";
 import { ART_SLOTS, artPathname, assetAddressIndex, pathnameRoles } from "./art-fields.mjs";
 import { embedRole } from "./content-embeds.mjs";
 import {
@@ -109,6 +109,7 @@ import { publishesContentPages } from "../content-config.mjs";
 import { HUGO_CONTENT } from "./site-config.mjs";
 import { homepageLinkTargets, relatedPages } from "./related-pages.mjs";
 import { HOLDINGS_KEYS, foreignHoldingsNodes, holdingsNode, holdingsPages } from "./holdings.mjs";
+import { WORKS_KEY, foreignWorksNodes, worksNode, worksPages } from "./literature-works.mjs";
 import { drawSiteMaps } from "./site-maps.mjs";
 
 const require = createRequire(import.meta.url);
@@ -607,6 +608,7 @@ export function pageFrontmatter(page, { decorate, webSrc, artSrc }) {
     delete data.aliases;
     delete data.related;
     for (const key of HOLDINGS_KEYS) delete data[key];
+    delete data[WORKS_KEY];
     delete data.map;
     if (webSrc && artSrc) resolveArtFields(data, webSrc, artSrc);
     return data;
@@ -1089,12 +1091,25 @@ export function renderPages(pages, options) {
         },
     );
 
+    // Each work of literature lists on the pages of the subjects it names,
+    // including works a fetched index carries.
+    const works = worksPages(
+        [
+            ...pages.map((page) =>
+                worksNode(page.fm, { title: pageTitle(page), url: page.url, package: page.pkg }),
+            ),
+            ...foreignWorksNodes(foreign?.index),
+        ],
+        { types: new Set(Object.keys(NOTE_VOCABULARY)) },
+    );
+
     let withMap = 0;
     const outputs = capture === true ? new Map() : null;
     for (const { page, body, data } of rendered) {
         const block = related.get(page.url);
         if (block) data.related = block;
         Object.assign(data, holdings.get(page.url));
+        Object.assign(data, works.get(page.url));
         const map = maps.get(page.url);
         if (map) {
             data.map = map.name;

package/engine/stub-lint.mjs

@@ -12,34 +12,18 @@
  */
 
 /**
- * An empty body must be deliberate.
+ * Every typed note needs a nonempty body.
  *
- * An empty body is what makes a note a **stub**, and the whole scheme turns on
- * that being on purpose rather than something somebody forgot. So four rules
- * hold the state honest, and two more report what the rules cannot decide:
+ * A missing or whitespace-only body is an error, whether or not the note has
+ * a `draft` tag or a frontmatter description. Placeholder-only bodies remain
+ * errors. A nonempty body below twenty-five words receives a warning when it
+ * is not tagged `draft`; the author decides whether that short note is done.
+ * A `folder` note is held only to the first rule: any nonempty body passes,
+ * with or without `draft`.
  *
- * 1. **A stub states what it is.** With nothing in the body, the `description`
- *    is the only sentence a reader gets and it is what every table and index
- *    prints. An **error**.
- * 2. **A stub is not tagged `draft`.** A thing not started is not a thing in
- *    progress. An **error**.
- * 3. **A body that renders to nothing is an abandoned draft, not a stub.** This
- *    is what keeps the empty-body rule's severity honest: the softer cases are
- *    *reported* rather than silently treated as one state or the other. An
- *    **error**.
- * 4. **A short unmarked body may be a draft that forgot its marker.** A
- *    **warning**, never an error — a note reading `See [[affiliation-meivor|Mëivōr]]`
- *    says everything it has to say, and a corpus holds many of them.
- * 5. **A long-standing draft is a report, not a finding.** It is unfinished,
- *    which the tag already says, so the oldest are listed and nobody is asked
- *    to dismiss a warning they cannot clear.
- * 6. **The counts are reported**, per package and per type, so the ratio of
- *    written to unwritten is visible on every run rather than discovered in a
- *    year.
- *
- * **What this does not decide is what earns a body.** Whether a given village
- * deserves prose is a question about a setting, and it belongs in the
- * repository that ships it. The toolchain's job is to make promotion free.
+ * Counts and the oldest drafts remain reports. Classification and indexing
+ * still derive full, draft and stub states from the existing note records;
+ * validation reports missing content without changing those records.
  *
  * @module
  */
@@ -50,7 +34,7 @@ import path from "node:path";
 import { authoredFrontmatter, isNoteRecord, isStub, noteFile } from "./index-records.mjs";
 import { positionInFrontmatter, positionOfLiteral } from "./diagnostics.mjs";
 import { parseMarkdownFile } from "./helpers.mjs";
-import { bodyWordCount, isStubNote, placeholderBody } from "./note-state.mjs";
+import { bodyWordCount, placeholderBody } from "./note-state.mjs";
 import { isDraftNote } from "./note-vocabulary.mjs";
 
 /**
@@ -67,16 +51,6 @@ export const SHORT_BODY_WORDS = 25;
 /** How many of the oldest drafts the report names. */
 const OLDEST_DRAFTS = 10;
 
-/**
- * Whether a note states a description.
- *
- * @param {Record<string, any>} fm - The note's authored frontmatter.
- * @returns {boolean} Whether `description` carries a sentence.
- */
-function hasDescription(fm) {
-    return String(fm?.description ?? "").trim() !== "";
-}
-
 /**
  * Check one note's state, and say where the fault is.
  *
@@ -87,32 +61,21 @@ function checkNote({ fm, body, file, raw }) {
     const findings = [];
     const at = (key, value) => positionInFrontmatter(raw, key, value, { topLevel: true });
 
-    if (isStubNote(fm, body)) {
-        if (!hasDescription(fm)) {
-            findings.push({
-                file,
-                ...at("type", fm.type),
-                severity: "error",
-                message:
-                    "this note has no body, so it is a stub — and a stub carries " +
-                    "a `description`, which is the only sentence a reader gets " +
-                    "and what every table listing it prints",
-            });
-        }
-        if (isDraftNote(fm)) {
-            findings.push({
-                file,
-                ...at("type", fm.type),
-                severity: "error",
-                message:
-                    "this note has no body and is tagged `draft`, and a thing " +
-                    "not started is not a thing in progress — remove the tag, " +
-                    "or write a body",
-            });
-        }
+    if (String(body ?? "").trim() === "") {
+        findings.push({
+            file,
+            ...at("type", fm.type),
+            severity: "error",
+            message:
+                "this note has no body — write a nonempty body, even when it is tagged `draft`",
+        });
         return findings;
     }
 
+    // A folder's body describes a pack folder rather than prose a reader is
+    // asked to finish, so any nonempty body is complete.
+    if (fm.type === "folder") return findings;
+
     const placeholders = placeholderBody(body);
     if (placeholders.length) {
         const [{ phrase }] = placeholders;
@@ -122,8 +85,7 @@ function checkNote({ fm, body, file, raw }) {
             severity: "error",
             message:
                 `this note's body says only "${phrase}", so it publishes a page ` +
-                `that tells a reader nothing — empty the body to make this a ` +
-                `stub, or write it`,
+                `that tells a reader nothing — replace the placeholder with content`,
         });
         return findings;
     }
@@ -204,8 +166,8 @@ export function lintNoteStates(contentBase, { records, contentPackage } = {}) {
         if (state === "draft") drafts.push({ file, modified: fs.statSync(absPath).mtime });
 
         // Held to the rules only where there is a note to hold: a file that
-        // declares no type declares nothing for them to read, and asking it for
-        // a `description` would report vault scaffolding as content.
+        // declares no type declares nothing for them to read; requiring its
+        // body would report vault scaffolding as content.
         if (record.type) findings.push(...checkNote({ fm, body, file, raw }));
     }
 

package/githooks/pre-push

@@ -4,7 +4,7 @@
 # container, over a clean export of HEAD — so a red GitHub check is something
 # you chose rather than something you discover.
 #
-# The steps are not listed here. `utils/ci-steps.mjs` reads them out of
+# The steps are not listed here. `ci/ci-steps.mjs` reads them out of
 # `.github/workflows/build.yml`, because a hook holding its own copy of the
 # command list is a second statement of one thing, and the copy is the one that
 # goes stale — silently, since running four of five steps still exits 0.

package/hugo-theme/layouts/partials/literature-works.html

@@ -0,0 +1,29 @@
+{{- /*
+  The "In song and story" card: the works of literature that name this page's
+  subject, rendered after the body and the geography and government card.
+
+  Front matter `@heroiclands/package-build` derives from every `literature`
+  lore note's `data.subjects`, and a note never authors itself:
+
+    works:  [{ title, url, form? }]  works naming this page, sorted by title
+
+  `form` is the work's `data.form` — an epic, a saga, a praise-song — printed
+  beside its name. Presence of the key is the only test: a page no work names
+  carries no `works` and renders no card. An entry with no `url` is a work
+  that publishes no page, rendered as plain text by `holdings/entry.html`.
+*/ -}}
+{{- with .Params.works -}}
+<section class="holdings literature-works" data-pagefind-ignore>
+  <div class="holdings-table">
+    <h3 class="holdings-table-label">In song and story</h3>
+    <ul class="holdings-table-grid">
+      {{- range . }}
+      <li>
+        {{- partial "holdings/entry.html" (dict "entry" . "class" "holdings-entry-name") -}}
+        {{- with .form }}<span class="holdings-entry-kind"> ({{ . }})</span>{{ end -}}
+      </li>
+      {{- end }}
+    </ul>
+  </div>
+</section>
+{{- end -}}

package/hugo-theme/layouts/partials/page-body.html

@@ -71,6 +71,7 @@
     </div>
 
     {{ partial "holdings.html" . }}
+    {{ partial "literature-works.html" . }}
     {{ partial "place-map.html" . }}
     {{ partial "related.html" . }}
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "22.27.0",
+    "version": "23.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",
@@ -182,6 +182,8 @@
     "scripts": {
         "test": "vitest run",
         "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",
         "build:types": "tsc -p tsconfig.dts.json",
         "build:asset-index": "node ci/emit-asset-index.mjs",

package/sohl/default-item-art.mjs

@@ -53,17 +53,17 @@
  * build translates once and no second copy of those three rows exists.
  */
 export const DEFAULT_ITEM_ART = {
-    affiliation: "sohl/assets/icons/noun/shield.svg",
+    affiliation: "sohl/assets/icons/noun/shieldnn.svg",
     affliction: "sohl/assets/icons/other/sick.svg",
     armorgear: "sohl/assets/icons/game-icons/lorc/breastplate.svg",
-    attribute: "sohl/assets/icons/other/charm.svg",
+    attribute: "sohl/assets/icons/game-icons/lorc/charm.svg",
     concoctiongear: "sohl/assets/icons/game-icons/badges/flask.svg",
     containergear: "sohl/assets/icons/other/sack.svg",
-    miscgear: "sohl/assets/icons/other/question-mark.svg",
-    mystery: "sohl/assets/icons/other/sparkles.svg",
-    mysticalability: "sohl/assets/icons/other/hand-sparkles.svg",
+    miscgear: "sohl/assets/icons/other/questionmark.svg",
+    mystery: "sohl/assets/icons/game-icons/delapouite/sparkles.svg",
+    mysticalability: "sohl/assets/icons/other/handsparkles.svg",
     projectilegear: "sohl/assets/icons/noun/arrow.svg",
-    skill: "sohl/assets/icons/other/head-gear.svg",
+    skill: "sohl/assets/icons/other/headgear.svg",
     trauma: "sohl/assets/icons/other/injury.svg",
     weapongear: "sohl/assets/icons/other/sword.svg",
 };