@heroiclands/package-build 17.2.0 → 18.0.0

package/sohl/default-item-art.mjs

@@ -40,6 +40,15 @@
  *
  * Paths are fully resolved (`systems/sohl/...`) — the served path both layers
  * need. If a new item type is added, add its default here.
+ *
+ * **The keys are SoHL *document* subtypes, not markdown note types.** The
+ * runtime reads this with `itemData.type`, which is a Foundry Item subtype, and
+ * that is the vocabulary a compendium document carries. The two vocabularies
+ * were the same string until #78 renamed three note types (`armorgear` →
+ * `armor`, and its two siblings), and this map stayed on the document side
+ * because that is the side the runtime cannot translate: `sohl/item-builders.mjs`
+ * asks SoHL's own note-type → subtype map before it looks art up here, so the
+ * build translates once and no second copy of those three rows exists.
  */
 export const DEFAULT_ITEM_ART = {
     affiliation: "systems/sohl/assets/icons/noun/shield.svg",
@@ -58,7 +67,8 @@ export const DEFAULT_ITEM_ART = {
 };
 
 /**
- * The default art path for an item `type`, or throw when the type is unknown —
+ * The default art path for an item **document subtype**, or throw when it is
+ * unknown —
  * the build's fail-fast contract, so an unrecognized type is never silently
  * defaulted (aborting the pack build rather than shipping a mismatched icon).
  *
@@ -66,8 +76,9 @@ export const DEFAULT_ITEM_ART = {
  * {@link DEFAULT_ITEM_ART} directly and fall back to Foundry's default instead
  * of calling this — see `SohlItem.getDefaultArtwork`.
  *
- * @param {string} type - the item type.
- * @returns {string} the default image path for that type.
+ * @param {string} type - The SoHL Item document subtype — `armorgear`, not the
+ *   `armor` note type that compiles into one.
+ * @returns {string} the default image path for that subtype.
  */
 export function defaultItemArt(type) {
     if (!(type in DEFAULT_ITEM_ART)) {

package/sohl/document-subtypes.mjs

@@ -28,13 +28,19 @@
  * silently. Sixteen lines of data are the price of the two vocabularies being
  * separately stated.
  *
- * **Today every row is the identity, and that is a fact about SoHL rather than
- * a rule.** The renames the format calls for (`armorgear` → `armor`, and its
- * three siblings) are #78, deliberately deferred: they cost 30,741 embedded
- * `(type, shortcode)` references across four content repositories, and until
- * they land the compiled packs must not move by a byte. When one does land it
- * changes one row here and the notes that address it — a data change, not a
- * mechanism change, which is the whole point of having the map first.
+ * **Three rows are no longer the identity, and that is what the map was for.**
+ * `armor`, `concoction` and `projectile` were renamed from the `…gear`
+ * spellings that named SoHL's *document* subtype rather than the thing the note
+ * is about (#78); the subtypes themselves did not move, so those three rows now
+ * say two different words where they used to say one twice. Landing the rename
+ * cost exactly what having the map first promised it would: a data change on
+ * three lines here, and no mechanism change anywhere.
+ *
+ * The old spellings are still read — {@link RENAMED_TYPES} normalises them
+ * before this map is consulted — so a tree that has not swept its 30,741
+ * embedded `(type, shortcode)` references compiles byte-identically. `weapon`
+ * is deliberately **not** among them: both systems call that document a
+ * `weapongear`, so the name says nothing SoHL-specific and #78 left it alone.
  *
  * **What this map is not.** It says which document a note becomes, never what
  * that document contains: the `system` block comes from the item registry's
@@ -65,14 +71,14 @@ export const SOHL_DOCUMENT_SUBTYPES = defineDocumentSubtypes({
     types: {
         affiliation: { document: "Item", subType: "affiliation" },
         affliction: { document: "Item", subType: "affliction" },
-        armorgear: { document: "Item", subType: "armorgear" },
+        armor: { document: "Item", subType: "armorgear" },
         attribute: { document: "Item", subType: "attribute" },
-        concoctiongear: { document: "Item", subType: "concoctiongear" },
+        concoction: { document: "Item", subType: "concoctiongear" },
         containergear: { document: "Item", subType: "containergear" },
         miscgear: { document: "Item", subType: "miscgear" },
         mystery: { document: "Item", subType: "mystery" },
         mysticalability: { document: "Item", subType: "mysticalability" },
-        projectilegear: { document: "Item", subType: "projectilegear" },
+        projectile: { document: "Item", subType: "projectilegear" },
         skill: { document: "Item", subType: "skill" },
         trauma: { document: "Item", subType: "trauma" },
         weapongear: { document: "Item", subType: "weapongear" },

package/sohl/item-builders.mjs

@@ -47,6 +47,8 @@
  */
 
 import { defaultItemArt } from "./default-item-art.mjs";
+import { documentSubtype } from "../engine/document-subtypes.mjs";
+import { SOHL_DOCUMENT_SUBTYPES } from "./document-subtypes.mjs";
 import { buildFromFields, readField } from "../engine/field-spec.mjs";
 import { COMBAT_TECHNIQUE_STRIKE_MODE, ITEM_FIELDS } from "./item-fields.mjs";
 
@@ -82,11 +84,18 @@ const FINALIZERS = Object.freeze({
  * throws and this module evaluates at import. A drift that a test used to catch
  * is unrepresentable.
  *
- * Importing the art map keeps this module a leaf — it is plain data, not the
- * resolved configuration, and the cycle the module note above warns about is
- * only ever closed by reading configuration back out.
+ * **The art map is keyed by the document subtype**, which the runtime reads
+ * with a Foundry `Item`'s own `type`, so this asks SoHL's map what an `armor`
+ * note becomes before looking art up (#78). Translating on the build side is
+ * the only place it can happen: the runtime has no note in hand. Every SoHL
+ * Item row is one-to-one, so `documentSubtype` needs no frontmatter and cannot
+ * throw for a discriminator.
  *
- * @param {string} type - The item type, and the art map's key.
+ * Importing the art map and SoHL's own subtype map keeps this module a leaf —
+ * both are plain data, not the resolved configuration, and the cycle the module
+ * note above warns about is only ever closed by reading configuration back out.
+ *
+ * @param {string} type - The note type, and {@link ITEM_FIELDS}'s key.
  * @returns {Readonly<{system: (fm: object) => object, img: string, fields: readonly object[]}>}
  *   The registry entry.
  */
@@ -96,7 +105,7 @@ function entryFor(type) {
     const finalize = FINALIZERS[type];
     return Object.freeze({
         system: finalize ? (fm) => finalize(fm, build(fm)) : build,
-        img: defaultItemArt(type),
+        img: defaultItemArt(documentSubtype(SOHL_DOCUMENT_SUBTYPES, type, {}) ?? type),
         fields,
     });
 }

package/sohl/item-fields.mjs

@@ -51,7 +51,7 @@ import {
     resolveCharges,
     resolveRelation,
     resolveSkillAptitudes,
-    sohlField,
+    sohlSystemField,
 } from "../engine/frontmatter.mjs";
 
 /* --------------------------------------------------------------------- */
@@ -115,6 +115,27 @@ const RELATION = Object.freeze({
     read: (_raw, { fm }) => resolveRelation(fm, noteContext(fm, "affiliation")),
 });
 
+/**
+ * A list of references, each a bare shortcode.
+ *
+ * Blank entries are dropped rather than emitted: a list that has been edited
+ * down in a property editor keeps its empty rows, and an empty string is not a
+ * reference to anything. Absent reads as `[]`, because "refers to nothing" is a
+ * value here — a sovereign polity is subordinate to nobody — rather than an
+ * unset one.
+ */
+const SHORTCODE_LIST = Object.freeze({
+    shape: "list of shortcodes",
+    kind: "list",
+    read: (raw) =>
+        (Array.isArray(raw) ? raw
+        : raw == null || raw === "" ? []
+        : [raw]
+        )
+            .map((entry) => String(entry ?? "").trim())
+            .filter((entry) => entry !== ""),
+});
+
 /**
  * Every element must carry a non-blank `shortcode`, unique on the weapon — the
  * shortcode is the mode's identity. The list is otherwise emitted verbatim.
@@ -141,11 +162,14 @@ const STRIKE_MODES = Object.freeze({
  * A projectile's impact die, read wherever the default of another impact field
  * depends on it.
  *
+ * Authored `impact.die`, stored `impactBase.die` — the one re-reading field
+ * whose two positions are spelled differently, so both are named (#126).
+ *
  * @param {object} fm - The note's frontmatter.
  * @returns {number} The die size, `0` when the projectile declares none.
  */
 function impactDie(fm) {
-    return Number(sohlField(fm, "impact.die", 0)) || 0;
+    return Number(sohlSystemField(fm, "impactBase.die", 0, { legacyKey: "impact.die" })) || 0;
 }
 
 /** A strike mode discriminated by `type`, mandatory on a combat technique. */
@@ -281,12 +305,49 @@ export const ITEM_FIELDS = Object.freeze({
             describe: "Standing within the society.",
         },
         {
-            name: "relation",
-            to: "relation",
+            // Plural because the field holds a map of many standings, one per
+            // affiliation — the singular was a misnomer every author read past
+            // (SoHL#1781).
+            name: "relations",
+            to: "relations",
             ...RELATION,
             default: {},
             describe: "How this society regards others: aligned, unaligned, rival or nemesis.",
         },
+        {
+            // The organisational relation: which bodies this one answers to.
+            // A list, because an affiliation may sit under more than one at
+            // once — an arcane tradition within an order, say.
+            name: "parents",
+            to: "parents",
+            ...SHORTCODE_LIST,
+            default: [],
+            describe: "Affiliations this one is subordinate to, by shortcode.",
+        },
+        {
+            // Not `capital` or `headquarters`: each fits about half the eleven
+            // subTypes, while a seat covers a polity, a guild, an order and a
+            // faith alike.
+            name: "seat",
+            to: "seat",
+            ...BLANK_IS_NULL,
+            default: null,
+            describe: "Where the affiliation's authority sits, by place shortcode.",
+        },
+        {
+            // The geographic relation, kept apart from the organisational one
+            // above: `parents` is *subordinate to*, this is *holds sway over*.
+            //
+            // Authored plural and emitted singular, as the content format's
+            // mapping row states (`data.domains` → `system.domain`). The two
+            // spellings are deliberate rather than a slip, so the declaration
+            // carries both rather than either side guessing.
+            name: "domains",
+            to: "domain",
+            ...SHORTCODE_LIST,
+            default: [],
+            describe: "Places this affiliation holds sway over, by shortcode.",
+        },
     ]),
 
     affliction: Object.freeze([
@@ -355,7 +416,7 @@ export const ITEM_FIELDS = Object.freeze({
         },
     ]),
 
-    armorgear: Object.freeze([
+    armor: Object.freeze([
         ...GEAR_COMMON,
         {
             name: "material",
@@ -470,7 +531,7 @@ export const ITEM_FIELDS = Object.freeze({
         },
     ]),
 
-    concoctiongear: Object.freeze([
+    concoction: Object.freeze([
         ...GEAR_COMMON,
         {
             name: "subType",
@@ -613,7 +674,7 @@ export const ITEM_FIELDS = Object.freeze({
         },
     ]),
 
-    projectilegear: Object.freeze([
+    projectile: Object.freeze([
         ...GEAR_COMMON,
         {
             name: "subType",

package/sohl/items.mjs

@@ -12,282 +12,68 @@
  */
 
 /**
- * Items pack compiler — produces JSON pack files for the single "items"
- * Foundry compendium from markdown notes in the `assets/content/` tree.
+ * **SoHL's Item pass** — the two things about compiling a note into a SoHL Item
+ * that are facts about SoHL rather than about the note format.
  *
- * The content root (`contentBase`) is walked recursively; any `.md` file whose
- * frontmatter declares a recognized `type:` is compiled into one JSON entry.
- * Files outside the whitelist (blog posts, rules text, templates) are
- * silently skipped.
+ * Everything else lives in {@link module:engine/item-compiler}: claiming a
+ * note, looking its subtype up in the system's map, dispatching to the
+ * consumer's registry, merging the authored `sohl.system` block, checking what
+ * was emitted against the receiving schema, and writing the envelope. That was
+ * all here until a second system needed it (#139), and it reached its
+ * system-specific facts through one constant read off SoHL's own map — which is
+ * why lifting it cost a subclass rather than a rewrite.
  *
- * Type-specific `system.*` fields come from the nested `sohl:` block in
- * vault frontmatter, read via `sohlField()`. The body is **not** rendered
- * here: it compiles into the item's doc in the journals pack, and
- * `system.docHtml` becomes a pointer to it (see `item-docs.mjs`). Folder
- * assignment is deferred — every item currently emits `folder: null`.
+ * What stays:
+ *
+ * - **The map**, declared in `document-subtypes.mjs` and named here, which
+ *   decides which notes this pass claims and what each one becomes (#79).
+ * - **`commonSystem`** — `shortcode`, `templatePriority`, `actionDefs`, `notes` and
+ *   `docHtml`, which SoHL's compiler writes on every item of every type and no
+ *   field declaration states.
  *
  * Not a standalone script — exports the `Items` compiler class, imported and
- * driven by `packages/content-build/engine/generate.mjs` (via `npm run build:compiledb`).
+ * driven by `engine/generate.mjs`.
  *
- * The walk itself — filtering by type, expanding tables, converting
- * wikilinks, writing the JSON and counting errors — belongs to {@link sohl.utils.packs.BasePackCompiler}; this module
- * states only what makes this pass its own (#1509).
+ * @module
  */
 
-import log from "loglevel";
-
-import {
-    sohlField,
-    resolveName,
-    resolveImg,
-    defaultStats,
-    systemArchetype,
-} from "../engine/helpers.mjs";
-import { BasePackCompiler } from "../engine/base-compiler.mjs";
-// Per-type default art lives in one framework-free module shared with the
-// runtime (`SohlItem.getDefaultArtwork`), so the two can't drift — see #932.
-// It lives in the build package, not `src/`: a relative path out of the package
-// resolves to garbage once this pipeline runs from `node_modules` (#1510).
-import { journalPageId, splitPages } from "../engine/journals.mjs";
-import { foundryPackageId } from "../engine/content-package.mjs";
-import { itemDocEntryId, itemDocPointer } from "../engine/item-docs.mjs";
-// The whitelist and the per-type `system` builders both come from the resolved
-// configuration, so the types this pass claims and the builders it compiles
-// them with are one table — the consuming repository's, not this package's
-// (#1504/#1563).
-import { itemTypes, itemBuilder, itemArt } from "../engine/item-registry.mjs";
-// Which Foundry Item subtype a note's `type` compiles into. Looked up in the
-// system's declared map, never inferred from the type itself (#79).
-import { documentSubtype, subtypeRow } from "../engine/document-subtypes.mjs";
+import { systemTemplatePriority } from "../engine/helpers.mjs";
+import { SystemItemCompiler } from "../engine/item-compiler.mjs";
 import { SOHL_DOCUMENT_SUBTYPES } from "./document-subtypes.mjs";
-// The note-level `sohl:` block: `sohl.system` onto the document's `system`
-// verbatim, and `sohl.img` / `sohl.effects` / `sohl.flags` overriding their
-// shared top-level forms for this system alone (#58).
-import { blockProperty, claimedPaths, mergeSystemData } from "../engine/system-block.mjs";
-import { itemFields } from "../engine/item-registry.mjs";
-
-/**
- * The description an item carries: a pointer to its **item doc**, the
- * JournalEntry the journals pass compiles this same body into (#1348).
- *
- * The prose is not rendered here at all. Carrying it would duplicate it onto
- * every actor holding the item — 7.59 MB of copies across the actors pack, of
- * which 133 KB was distinct — where a link is 60 bytes and always current. The
- * two passes derive the target from the note's own id, so neither has to see
- * the other's output; both split the *converted* markdown, so an H1 carrying a
- * wikilink names the same page on both sides.
- *
- * An item with no prose points at nothing, exactly as the journals pass writes
- * no entry for it.
- *
- * @param {string} markdown - The note body, tables expanded and wikilinks
- *   resolved.
- * @param {object} fm - The note's frontmatter.
- * @param {string} name - The item's name.
- * @returns {string} The pointer, or "" for a note with no body.
- */
-function itemDescription(markdown, fm, name) {
-    if (!String(markdown).trim()) return "";
-    const [leadPage] = splitPages(markdown, name);
-    const pageId = journalPageId(itemDocEntryId(fm.id), leadPage, 0);
-    return itemDocPointer(foundryPackageId(), fm.id, name, pageId);
-}
-
-/**
- * Build the `system.*` fields shared by every item type:
- *   shortcode, archetype, actionDefs, notes, docHtml.
- *
- * @param {object} fm - The note's frontmatter.
- * @param {string} description - The item's documentation pointer.
- * @param {string} label - Human-readable context for error messages.
- * @returns {object} The shared `system` fields.
- */
-function commonSystem(fm, description, label) {
-    return {
-        shortcode: fm.shortcode,
-        // Required nullable number: a priority, or `null` for a document that
-        // is not an archetype (#126 / archetype contract #604).
-        archetype: systemArchetype(fm, label),
-        actionDefs: Array.isArray(fm.actionDefs) ? fm.actionDefs : [],
-        notes: "",
-        docHtml: description || "",
-    };
-}
-
-/* -------------------------------------------------------------------- */
-/*  Synthesized Active Effects                                          */
-/* -------------------------------------------------------------------- */
-
-/* -------------------------------------------------------------------- */
-/*  Compiler                                                            */
-/* -------------------------------------------------------------------- */
-
-/**
- * The system this pass compiles for — the block its notes write, and the
- * registry its builders come from.
- *
- * Read from the map rather than spelled here, so the block name, the subtype
- * map and the registry key are one statement (#58/#79).
- *
- * @type {string}
- */
-const SYSTEM = SOHL_DOCUMENT_SUBTYPES.block;
-
-export class Items extends BasePackCompiler {
-    static id = "items";
-    static label = "item";
-
-    /**
-     * An Item **is** a system's data, so this pack takes only notes carrying
-     * this system's block (#58).
-     */
-    static requiresSystemBlock = true;
 
+export class Items extends SystemItemCompiler {
     /**
-     * How many of each item type this pass wrote, for the summary. Every type
-     * is present from the start so the tally reads as a census of the
-     * whitelist rather than of what happened to compile.
+     * SoHL's note-type → document-subtype map — the one declaration that says
+     * which block this pass reads, which notes it claims, and what each becomes
+     * (#58/#79).
      *
-     * @type {Record<string, number>}
+     * @type {import("../engine/document-subtypes.mjs").DocumentSubtypeMap}
      */
-    counts = Object.fromEntries([...itemTypes()].map((t) => [t, 0]));
+    static documentSubtypes = SOHL_DOCUMENT_SUBTYPES;
 
     /**
-     * Every content type that compiles into an item.
-     *
-     * The whitelist is the consuming repository's `itemBuilders` keys (#1504),
-     * and the system's own map is a second filter on top of it: a type SoHL
-     * maps onto some *other* document class is not an item however a registry
-     * spells it, which is the "no wrongly-typed document" half of #79. A type
-     * the map does not name at all is left to the registry — see
-     * {@link Items#itemSubtype}.
+     * The `system.*` fields SoHL writes on every item, whatever its type:
+     * shortcode, templatePriority, actionDefs, notes, docHtml.
      *
      * @param {object} fm - The note's frontmatter.
-     * @returns {boolean} True for a whitelisted item type.
+     * @param {object} at - What the pass already knows about this note.
+     * @param {string} at.description - The pointer to the note's item doc.
+     * @param {string} at.label - Human-readable context for error messages.
+     * @returns {object} The shared `system` fields.
      */
-    selects(fm) {
-        if (!fm.type || !itemTypes().has(fm.type)) return false;
-        const row = subtypeRow(SOHL_DOCUMENT_SUBTYPES, fm.type);
-        return !row || row.document === "Item";
-    }
-
-    /**
-     * The Foundry Item subtype a note compiles into.
-     *
-     * **Looked up, not inferred.** For every type this system declares, the
-     * emitted subtype is the map's, so the note vocabulary and the document
-     * vocabulary are two separately-stated things rather than one string
-     * written twice (#79).
-     *
-     * **A type the map does not name belongs to the consumer**, and its
-     * registry entry is the declaration: a repository shipping an item type of
-     * its own writes it once, in the `itemBuilders` table of its
-     * `package-build.config.yaml`, and that key is what the document is a
-     * subtype of. That is an authored statement in the consumer's own
-     * configuration, not a coincidence inside this package's source — and
-     * refusing it here would silently drop every document of a type SoHL has
-     * no opinion about (#7/#1563).
-     *
-     * @param {object} fm - The note's frontmatter.
-     * @returns {string} The document's `type`.
-     */
-    itemSubtype(fm) {
-        const declared = documentSubtype(SOHL_DOCUMENT_SUBTYPES, fm.type, fm, {
-            absPath: this.currentNote?.absPath,
-        });
-        return declared ?? fm.type;
-    }
-
-    /** An item is named by its own type in the log, not by "item". */
-    noteLabel(fm) {
-        return fm.type;
-    }
-
-    /**
-     * Construct the full compendium envelope for one item, including
-     * synthesized Active Effects where applicable.
-     *
-     * @param {object} fm - The note's frontmatter.
-     * @param {string} markdown - The body, tables expanded and wikilinks
-     *   resolved.
-     * @returns {object} The item document, keyed for the pack.
-     */
-    buildEntry(fm, markdown) {
-        const type = fm.type;
-        const name = resolveName(fm);
-        const description = itemDescription(markdown, fm, name);
-        const id = fm.id;
-        const subType = this.itemSubtype(fm);
-        const system = {
-            ...commonSystem(fm, description, `item "${name}"`),
-            ...itemBuilder(type, SYSTEM)(fm),
-        };
-        // Whatever the note authors under `sohl.system`, at the DataModel's own
-        // paths. A path a declared field already writes is left to that field:
-        // its value came from the same authored place and went through the
-        // field's own coercion (#58).
-        mergeSystemData(system, fm, {
-            block: SYSTEM,
-            claimed: claimedPaths(itemFields(type, SYSTEM)),
-        });
-        this.reportUndeclaredSystemData(fm, SYSTEM, "Item", subType);
-        // And what *this* pass wrote on its own initiative — `shortcode`,
-        // `archetype`, `actionDefs`, `notes`, `docHtml` — which no field
-        // declaration states and so no other check can see (#155). Read off the
-        // assembled block, so a key added to `commonSystem` is checked without
-        // anyone remembering to list it.
-        this.reportEmittedSystemData(system, {
-            fm,
-            block: SYSTEM,
-            documentType: "Item",
-            subType,
-            type,
-            fields: itemFields(type, SYSTEM),
-        });
-
-        const effects = blockProperty(fm, SYSTEM, "effects");
-        const folderId = sohlField(fm, "folder", null);
-        const folder = this.folderResolver(folderId);
-
+    commonSystem(fm, { description, label }) {
         return {
-            name,
-            // The note's `type` addresses the builder and the default art —
-            // both registries are keyed by content type — while the document's
-            // own subtype comes from the system's map (#79).
-            type: subType,
-            // Nullish, not `||` (#218): `resolveImg` returns `null` for a note
-            // that names no art and `""` for one that wants none, and only the
-            // first may be replaced by the type's default.
-            img: resolveImg(blockProperty(fm, SYSTEM, "img")) ?? itemArt(type, SYSTEM),
-            _id: id,
-            system,
-            effects: Array.isArray(effects) ? [...effects] : [],
-            // Whatever the note authors, and nothing else. `archetype` used to
-            // be spliced in here as `flags.sohl.docArchetype`; it is a schema
-            // field now and sits in `system` (#126).
-            flags: blockProperty(fm, SYSTEM, "flags", {}),
-            _stats: this.stats,
-            ownership: { default: 0 },
-            folder,
-            _key: `!items!${id}`,
+            shortcode: fm.shortcode,
+            // Required nullable number: a priority, or `null` for a document
+            // that is not a template (#126 / archetype contract #604). The
+            // field was `system.archetype` until #266 / sohl#1836; the receiving
+            // schema declares only the new name, so the emitted key moves with
+            // it — an undeclared `system` key is discarded at construction
+            // without a warning.
+            templatePriority: systemTemplatePriority(fm, label),
+            actionDefs: Array.isArray(fm.actionDefs) ? fm.actionDefs : [],
+            notes: "",
+            docHtml: description || "",
         };
     }
-
-    /** @inheritdoc */
-    onCompiled(fm) {
-        this.counts[fm.type]++;
-    }
-
-    /** @inheritdoc */
-    reportCompiled(stats) {
-        log.info(`Compiled ${stats.compiled} items:`);
-        for (const [t, n] of Object.entries(this.counts)) {
-            if (n > 0) log.info(`  ${t}: ${n}`);
-        }
-    }
-
-    /** @inheritdoc */
-    reportDetail(stats) {
-        log.debug(`Skipped ${stats.skippedOther} non-item file(s) (no recognized type)`);
-    }
 }

package/sohl/note-schemas.mjs

@@ -244,7 +244,7 @@ const MAP_FIELDS = Object.freeze([
  * @type {Readonly<Record<string, readonly import("../engine/field-spec.mjs").FieldSpec[]>>}
  */
 const PRESENTATION_FIELDS = Object.freeze({
-    armorgear: Object.freeze([
+    armor: Object.freeze([
         {
             name: "craft",
             ...MAP,
@@ -291,7 +291,7 @@ const PRESENTATION_FIELDS = Object.freeze({
                 "The craft that makes it — `{skill, secondary}` — for knowledgebase grouping.",
         },
     ]),
-    projectilegear: Object.freeze([
+    projectile: Object.freeze([
         {
             name: "craft",
             ...MAP,