@heroiclands/package-build 17.2.0 → 18.0.0

package/hm3/actors.mjs

@@ -0,0 +1,352 @@
+/*
+ * 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
+ */
+
+/**
+ * **HM3's Actor pass** — what an HM3 `character` or `creature` holds.
+ *
+ * The machinery is {@link module:engine/actor-compiler}'s and is shared with
+ * the SoHL pass: the predefined-item catalogue, the note-vocabulary →
+ * document-subtype translation each embedded reference goes through (#140), the
+ * merge and the stable embedded ids. This module states HM3's data model and
+ * nothing else.
+ *
+ * **A being note is one Actor per system, and the subtype is authored.** HM3
+ * splits what a note calls a `being` into a `character` and a `creature`, and
+ * nothing in the note's own vocabulary partitions cleanly onto that split — so
+ * the note says which, by writing `hm3.type`. An absent one is an error naming
+ * the note, never a default (#139).
+ *
+ * **What is emitted, and what is deliberately not.** Four rows of the content
+ * format's `being` mapping table give HM3 a destination — `data.portrait` →
+ * `system.bioImage`, `data.species`, `data.gender`, `data.occupation`, and
+ * `data.templatePriority` → `flags.hm3.templatePriority` — and, since #305,
+ * three of them are *declared as those sources* rather than as the bare key the
+ * corpus writes, so the specification's mapping is executable rather than
+ * aspirational. Plus the two anchored prose sections: `{#appearance}` is HM3's `description` and `{#dossier}` its
+ * `biography`. Everything else an HM3 actor carries — the thirteen abilities,
+ * the sunsign, `move`, `fatigue`, `shockIndex`, a creature's `loadRating` — has
+ * no shared source stated anywhere, so it is authored at its own path under
+ * `hm3.system` and reaches the document through the verbatim passthrough. It is
+ * checked against HM3's published `schema.json` like everything else; it simply
+ * is not invented here.
+ *
+ * `gender` and `occupation` are written **only on a `character`**, because that
+ * is the only subtype HM3 declares them on. Emitting them on a creature would
+ * be a key Foundry discards at load without a word — which is exactly what the
+ * emitted-`system` check would report, on every creature in the pack.
+ *
+ * @module
+ */
+
+import { resolveName, resolveImg } from "../engine/helpers.mjs";
+import { buildFromFields, STRING } from "../engine/field-spec.mjs";
+import { SystemActorCompiler } from "../engine/actor-compiler.mjs";
+import { renderSection } from "../engine/anchored-sections.mjs";
+import { documentSubtype } from "../engine/document-subtypes.mjs";
+import { HM3_DOCUMENT_SUBTYPES } from "./document-subtypes.mjs";
+import { templateFlags } from "./template-priority.mjs";
+// The retirement window's report, shared with the frontmatter lint so the
+// two cannot say different things about the same key (#305).
+import { legacyKeyMessage, locateFrontmatterKey } from "../engine/retired-fields.mjs";
+// The note-level `hm3:` block: `hm3.system` onto the document's `system`
+// verbatim, and `hm3.img` / `hm3.items` / `hm3.effects` / `hm3.flags`
+// overriding their shared top-level forms for this system alone (#58).
+import { blockField, blockProperty, mergeSystemData } from "../engine/system-block.mjs";
+
+/**
+ * The shared `data:` facts every HM3 actor takes, whatever its subtype.
+ *
+ * Declared rather than read by hand, so a value resolves by the same order
+ * every other declared field does — `hm3.system.<to>` first, then the in-block
+ * position, then the shared source, then the default (#58) — and so the
+ * author-facing reference can be generated from the same statement the compiler
+ * obeys (#22).
+ *
+ * **Both positions, named separately (#305).** The specification maps
+ * `data.species` onto `system.species`, and every HM3 note in the corpus writes
+ * `hm3.species`. Until #126 sweeps them those are two live positions for one
+ * field, so the declaration names both: `name` is the shared source, `legacyKey`
+ * the key the block still carries, and the block wins while it is there. Naming
+ * only one of them is what made the row unreadable — a plain `species` could
+ * not see `data.species`, and a dotted `data.species` could not see the 2,512
+ * notes that carry `hm3.species`, each yielding `""` in silence.
+ *
+ * @type {readonly import("../engine/field-spec.mjs").FieldSpec[]}
+ */
+const ACTOR_FIELDS = Object.freeze([
+    {
+        name: "data.species",
+        legacyKey: "species",
+        to: "species",
+        ...STRING,
+        default: "",
+        describe: "The kind of creature this is.",
+    },
+]);
+
+/**
+ * The two `data:` facts HM3 declares on a `character` and not on a `creature`.
+ *
+ * Both name their shared source and their legacy in-block key, for the reason
+ * {@link ACTOR_FIELDS} does.
+ *
+ * @type {readonly import("../engine/field-spec.mjs").FieldSpec[]}
+ */
+const CHARACTER_FIELDS = Object.freeze([
+    {
+        name: "data.gender",
+        legacyKey: "gender",
+        to: "gender",
+        ...STRING,
+        default: "",
+        describe: "The character's gender.",
+    },
+    {
+        name: "data.occupation",
+        legacyKey: "occupation",
+        to: "occupation",
+        ...STRING,
+        default: "",
+        describe: "What the character does for a living.",
+    },
+]);
+
+/**
+ * Default art per HM3 actor **subtype**, applied when the note supplies no
+ * `img` / `portrait`.
+ *
+ * The two paths HM3's own actor model and migration use, so a compiled actor
+ * looks like one created in the client.
+ *
+ * @type {Readonly<Record<string, string>>}
+ */
+const DEFAULT_IMG = Object.freeze({
+    character: "systems/hm3/images/svg/knight-silhouette.svg",
+    creature: "systems/hm3/images/svg/monster-silhouette.svg",
+});
+
+/**
+ * The default art for an HM3 actor subtype.
+ *
+ * Fail-fast, for the reason the item art map is: a subtype with no art would
+ * otherwise ship a document with no image and nothing said about it.
+ *
+ * @param {string} subType - The Foundry actor subtype.
+ * @returns {string} The default image path.
+ * @throws {Error} When this map pairs no art with the subtype.
+ */
+function defaultActorImg(subType) {
+    const img = /** @type {Record<string, string|undefined>} */ (DEFAULT_IMG)[subType];
+    if (!img) {
+        throw new Error(
+            `No default art for HM3 actor subtype "${subType}" — add an entry ` +
+                `to \`DEFAULT_IMG\` in hm3/actors.mjs, beside the map row that ` +
+                `introduced the subtype.`,
+        );
+    }
+    return img;
+}
+
+export class Hm3Actors extends SystemActorCompiler {
+    /**
+     * HM3's note-type → document-subtype map — the one declaration that says
+     * which block this pass reads, which notes it claims, and what each
+     * becomes. It is also what every embedded reference is translated through.
+     *
+     * @type {import("../engine/document-subtypes.mjs").DocumentSubtypeMap}
+     */
+    static documentSubtypes = HM3_DOCUMENT_SUBTYPES;
+
+    /**
+     * Compile one `being` note into its HM3 actor document.
+     *
+     * @param {object} fm - The note's frontmatter.
+     * @param {string} markdown - The body, tables expanded and wikilinks
+     *   resolved.
+     * @returns {object} The actor document, keyed for the pack.
+     */
+    buildEntry(fm, markdown) {
+        return this.buildActor(this.itemsMap, fm, markdown);
+    }
+
+    /**
+     * Build every embedded item an HM3 actor carries, from `hm3.items`.
+     *
+     * One list, not two: HM3 keeps a character's abilities in `system.abilities`
+     * rather than as embedded documents, so there is no attributes map to
+     * expand the way SoHL's pass expands `sohl.attributes`.
+     *
+     * @param {Map<string, object>} itemsMap - The predefined items, by address.
+     * @param {string} actorId - The owning actor's id, seeding embedded ids.
+     * @param {object} fm - The note's frontmatter.
+     * @param {string} ctx - Diagnostic context (the actor's label).
+     * @returns {object[]} The embedded items.
+     */
+    buildEmbeddedItems(itemsMap, actorId, fm, ctx) {
+        const items = [];
+        const declared = blockField(fm, this.system, "items", null);
+        if (!Array.isArray(declared)) return items;
+
+        declared.forEach((entry, index) => {
+            if (!entry || typeof entry !== "object") {
+                this.noteError(`${ctx}: ${this.system}.items[${index}] is not an object`);
+                this.errorCount++;
+                return;
+            }
+            const { shortcode, type, ...rest } = entry;
+            if (!type) {
+                this.noteError(`${ctx}: ${this.system}.items[${index}] missing type`);
+                this.errorCount++;
+                return;
+            }
+            const embedded = this.resolveEmbedded(
+                itemsMap,
+                actorId,
+                type,
+                shortcode || null,
+                rest,
+                `items:${index}`,
+                ctx,
+                { fmKey: "items" },
+            );
+            if (embedded) items.push(embedded);
+        });
+        return items;
+    }
+
+    /**
+     * Build one HM3 actor document from a `being` note.
+     *
+     * @param {Map<string, object>} itemsMap - The predefined items, by address.
+     * @param {object} fm - The note's frontmatter.
+     * @param {string} body - The note body, converted.
+     * @returns {object} The actor document, keyed for the pack.
+     */
+    buildActor(itemsMap, fm, body) {
+        const block = this.system;
+        const name = resolveName(fm);
+        const id = fm.id;
+        const ctx = `actor "${name}"`;
+        // The document's own subtype, and the art that goes with it. Both are
+        // looked up from the note's `type` rather than spelled here (#79); for
+        // HM3 the row is one-to-many, so the note's `hm3.type` decides.
+        const subType = /** @type {string} */ (
+            documentSubtype(this.documentSubtypes, fm.type, fm, {
+                absPath: this.currentNote?.absPath,
+            })
+        );
+        const defaultImg = defaultActorImg(subType);
+
+        const items = this.buildEmbeddedItems(itemsMap, id, fm, ctx);
+
+        // The sweep's progress signal, reported where an author meets it
+        // soonest — every consumer runs the compile, and not every one runs the
+        // lint (#142). A warning: the note compiles to the correct document
+        // either way, and refusing the position comes once no tree writes it.
+        const onLegacyKey = (field) =>
+            this.noteWarn(
+                legacyKeyMessage(block, field),
+                locateFrontmatterKey(this.currentNote?.absPath, field.legacyKey),
+            );
+
+        // Both spellings, as everywhere else: `packFolder` is a folder note's
+        // address and `folder` a Foundry id, and which one applies comes from
+        // the field it was written in rather than from the string (#251, #255).
+        // This pass read only the id, so an HM3 tree could not file an actor by
+        // address at all — which its own sweep needs.
+        const packFolderAddress = blockField(fm, block, "packFolder", null);
+        const folder =
+            packFolderAddress ?
+                this.folderResolver(packFolderAddress, { isAddress: true })
+            :   this.folderResolver(blockField(fm, block, "folder", null));
+
+        const system = {
+            // Nullish, not `||` (#218): a note that names no portrait gets the
+            // subtype's default, one that writes `""` ships blank on purpose.
+            bioImage: resolveImg(blockProperty(fm, block, "portrait")) ?? defaultImg,
+            description: renderSection(body || "", "appearance"),
+            biography: renderSection(body || "", "dossier"),
+            ...buildFromFields(ACTOR_FIELDS, { block, onLegacyKey })(fm),
+            // Declared on `character` alone, so written there alone — see the
+            // module note.
+            ...(subType === "character" ?
+                buildFromFields(CHARACTER_FIELDS, { block, onLegacyKey })(fm)
+            :   {}),
+        };
+
+        // Whatever the note authors under `hm3.system`, at the DataModel's own
+        // paths (#58). This pass has no field declaration, so it claims
+        // nothing: every authored path is the author's, and the fields above
+        // are what a note that authors none still gets.
+        mergeSystemData(system, fm, { block });
+        this.reportUndeclaredSystemData(fm, block, "Actor", subType);
+        // And what this pass wrote itself — there is no field declaration for a
+        // being at all, so every key above is a compiler emission (#155).
+        this.reportEmittedSystemData(system, {
+            fm,
+            block,
+            documentType: "Actor",
+            subType,
+            type: fm.type,
+        });
+
+        const effects = blockProperty(fm, block, "effects");
+        const img = resolveImg(blockProperty(fm, block, "img")) ?? defaultImg;
+
+        return {
+            name,
+            type: subType,
+            img,
+            _id: id,
+            system,
+            items,
+            prototypeToken: {
+                name,
+                displayName: 0,
+                actorLink: false,
+                texture: { src: img },
+                width: 1,
+                height: 1,
+                sight: { enabled: false },
+                detectionModes: [],
+            },
+            effects: Array.isArray(effects) ? [...effects] : [],
+            folder,
+            sort: 0,
+            ownership: { default: 0 },
+            // Whatever the note authors, plus the template priority — which HM3
+            // keeps in flags rather than in `system`, so there is nowhere in
+            // the data model for it to go.
+            flags: this.actorFlags(fm, block),
+            _stats: this.stats,
+            _key: `!actors!${id}`,
+        };
+    }
+
+    /**
+     * The document's `flags`: whatever the note authors, plus this system's
+     * template priority.
+     *
+     * The rule itself is {@link module:hm3/template-priority.templateFlags},
+     * because the Item pass writes the same flag from the same statement (#283)
+     * and two copies of it were one copy too many — this pass had the only one,
+     * and the Item pass had none.
+     *
+     * @param {object} fm - The note's frontmatter.
+     * @param {string} block - This pass's system block.
+     * @returns {object} The flags to emit.
+     */
+    actorFlags(fm, block) {
+        return templateFlags(fm, block);
+    }
+}

package/hm3/default-item-art.mjs

@@ -0,0 +1,75 @@
+/*
+ * 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
+ */
+
+/**
+ * Default HM3 item artwork, keyed by the **note** type that compiles into it.
+ *
+ * The registry contract is fail-fast (see {@link module:engine/item-registry.itemArt}):
+ * a type whose entry pairs no art aborts the pack build for a note that carries
+ * no `img:` of its own, rather than shipping a mismatched icon. So every type
+ * `item-builders.mjs` declares has a row here.
+ *
+ * **Paths are fully resolved.** `resolveImg` rewrites a leading `icons/` or
+ * `images/` to the *consuming package's* asset root, which is not where these
+ * live: they are shipped by the HM3 system. Written as `systems/hm3/images/…`
+ * they pass through untouched and address the icons HM3's own compendiums
+ * already use, so an item compiled from a note looks like its hand-authored
+ * neighbours.
+ *
+ * **A one-to-many type gets one default**, because art is keyed by note type
+ * and a note type is what a registry entry addresses. `weapongear` compiles
+ * into a weapon or a missile and defaults to the sword either way; a note whose
+ * subject is a thrown spear says so with an `img:` of its own. Keying art by
+ * document subtype instead would mean a second lookup that could disagree with
+ * the registry's, and the note-level override already answers the case.
+ *
+ * @module
+ */
+
+/**
+ * Note type → the image an HM3 item of that type ships with.
+ *
+ * @type {Readonly<Record<string, string>>}
+ */
+export const HM3_DEFAULT_ITEM_ART = Object.freeze({
+    armor: "systems/hm3/images/icons/svg/armor.svg",
+    armorlocation: "systems/hm3/images/icons/svg/anatomy.svg",
+    containergear: "systems/hm3/images/icons/svg/sack.svg",
+    miscgear: "systems/hm3/images/icons/svg/miscgear.svg",
+    mysticalability: "systems/hm3/images/icons/svg/psionics.svg",
+    projectile: "systems/hm3/images/icons/svg/arrow.svg",
+    skill: "systems/hm3/images/icons/svg/skills.svg",
+    trauma: "systems/hm3/images/icons/svg/injury.svg",
+    weapongear: "systems/hm3/images/icons/svg/sword.svg",
+});
+
+/**
+ * The default art path for an HM3 item type, or throw when the type is unknown.
+ *
+ * Reading this from `item-builders.mjs` is what keeps the two lists one: that
+ * module cannot declare a type this map does not cover, because this throws and
+ * that module evaluates at import.
+ *
+ * @param {string} type - The note type.
+ * @returns {string} The default image path for it.
+ * @throws {Error} When no art is paired with the type.
+ */
+export function hm3DefaultItemArt(type) {
+    if (!(type in HM3_DEFAULT_ITEM_ART)) {
+        throw new Error(
+            `No default art for HM3 item type "${type}" — add one to ` +
+                `@heroiclands/package-build/hm3/default-item-art`,
+        );
+    }
+    return /** @type {Record<string, string>} */ (HM3_DEFAULT_ITEM_ART)[type];
+}

package/hm3/document-subtypes.mjs

@@ -0,0 +1,134 @@
+/*
+ * 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
+ */
+
+/**
+ * **HM3's note-type → document-subtype map** — which Foundry document, and
+ * which subtype of it, a note of each content type compiles into for HârnMaster
+ * 3 (#139).
+ *
+ * The mechanism is `engine/document-subtypes.mjs`, the same one SoHL's
+ * declaration uses; the two halves share it and share nothing else. That is the
+ * `engine/` ÷ system line this package draws everywhere (#36), and this file is
+ * the first evidence that the line holds: a second system declared its map
+ * without a line of the mechanism changing.
+ *
+ * **Where this map differs from SoHL's, and why that matters.**
+ *
+ * SoHL's map was the identity in every row until #78 renamed three of them,
+ * which was a fact about SoHL rather than a rule (#79) — and while it stayed
+ * true nothing proved the map was doing any work. HM3's was never close. Four
+ * of its rows are one-to-many, one renames outright (`projectile` →
+ * `missilegear`), and five of its type names are SoHL's own with a *different
+ * data model* behind them. A build that inferred a subtype from a note's `type`
+ * would be wrong on nine rows out of ten here, and — worse — silently
+ * right-looking on the five shared names.
+ *
+ * **The five shared names.** `skill`, `weapongear`, `armor`, `containergear`
+ * and `miscgear` are declared by both systems. A SoHL skill
+ * stores `masteryLevelBase`; an HM3 skill stores `masteryLevel` and a `type` of
+ * `"Craft"`/`"Physical"`/…. Name-matching between the two would not fail — it
+ * would succeed wrongly, emitting a document Foundry accepts and then strips to
+ * nothing at load. So each name resolves through *its own system's* map and is
+ * built by *its own system's* registry, and the schema check reads that
+ * system's published `schema.json`.
+ *
+ * **The four one-to-many rows are authored, never derived.** A note says which
+ * HM3 subtype it is, in its own `hm3:` block, by writing `hm3.type`. Nothing is
+ * inferred from the note's `subType`: an author who says nothing gets an error
+ * naming the note and listing the permitted values, because a default would
+ * pick one of them and be right about half the time.
+ *
+ * `hm3.type` is not a new spelling. `type` is already one of the properties a
+ * system block may carry ({@link module:engine/system-block.BLOCK_DOCUMENT_PROPERTIES}),
+ * meaning "this system's document type"; the discriminator is that property,
+ * read where it was always going to be written.
+ *
+ * **What this map is not.** It says which document a note becomes, never what
+ * that document contains: the `system` block comes from `item-builders.mjs`
+ * here exactly as it does in `sohl/`.
+ *
+ * @module
+ */
+
+import { defineDocumentSubtypes } from "../engine/document-subtypes.mjs";
+
+/**
+ * The frontmatter key inside the `hm3:` block that resolves a one-to-many row.
+ *
+ * One key for all four rows, deliberately: an author who has learned it on a
+ * weapon has learned it on a trauma. It is the block's `type` property — the
+ * document type this system compiles the note into — which is what the content
+ * format has always called it.
+ *
+ * @type {string}
+ */
+export const HM3_TYPE_KEY = "type";
+
+/**
+ * Every content type HM3 compiles into a Foundry document, and what it becomes.
+ *
+ * The Item rows are the nine types `item-builders.mjs` declares; the one Actor
+ * row is `being`, which HM3 splits into `character` and `creature`. Types this
+ * map does not name — `affiliation`, `affliction`, `attribute`,
+ * `concoction`, `mystery`, and every core type — compile into no HM3
+ * document at all, silently and correctly: HM3 has no form of them, and a
+ * finding on every such note would be the noise #79's rule exists to prevent.
+ *
+ * @type {import("../engine/document-subtypes.mjs").DocumentSubtypeMap}
+ */
+export const HM3_DOCUMENT_SUBTYPES = defineDocumentSubtypes({
+    system: "hm3",
+    types: {
+        armor: { document: "Item", subType: "armorgear" },
+        // HM3-only: SoHL resolves a hit location from a being's own body
+        // structure, so it has no item of this kind and no note type for one.
+        armorlocation: { document: "Item", subType: "armorlocation" },
+        containergear: { document: "Item", subType: "containergear" },
+        miscgear: { document: "Item", subType: "miscgear" },
+        // The one outright rename. A note calls it a projectile; HM3 calls the
+        // document a missile.
+        projectile: { document: "Item", subType: "missilegear" },
+        skill: { document: "Item", subType: "skill" },
+
+        // ── the four one-to-many rows ───────────────────────────────────────
+        // SoHL keeps one `mysticalability` with a `system.subType`; HM3 has
+        // three separate documents, and nothing in the note's own subType
+        // vocabulary partitions cleanly onto them.
+        mysticalability: {
+            document: "Item",
+            discriminator: HM3_TYPE_KEY,
+            subTypes: ["psionic", "spell", "invocation"],
+        },
+        // SoHL's `trauma` gathers eleven kinds of harm under one item; HM3 has
+        // an `injury` for the physical and a `trait` for everything standing.
+        trauma: {
+            document: "Item",
+            discriminator: HM3_TYPE_KEY,
+            subTypes: ["injury", "trait"],
+        },
+        // SoHL distinguishes a weapon's uses with strike modes on one item; HM3
+        // assumes one usage per document, so a thrown spear is a *second*
+        // document. Which one a given note describes is the note's to say.
+        weapongear: {
+            document: "Item",
+            discriminator: HM3_TYPE_KEY,
+            subTypes: ["weapongear", "missilegear"],
+        },
+
+        being: {
+            document: "Actor",
+            discriminator: HM3_TYPE_KEY,
+            subTypes: ["character", "creature"],
+        },
+    },
+});

package/hm3/index.mjs

@@ -0,0 +1,56 @@
+/*
+ * 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 HM3-specific half of the toolchain: the knowledge of the HârnMaster 3
+ * data model that a generic content module must never receive (#139).
+ *
+ * The second half, and the first evidence that `engine/` ÷ system is a real
+ * line rather than an aspiration: HM3's item-type registry and its builders,
+ * its note-type → document-subtype map, its two compilers and its default-art
+ * map live here, and nothing in `@heroiclands/package-build/engine` exports any
+ * of it. It imports nothing from `sohl/` and `sohl/` imports nothing from it —
+ * the only thing the two share is the engine between them.
+ *
+ * A consuming repository that ships content for both systems names both
+ * registries — `itemBuilders: [sohl, hm3]` — and declares one pack per system
+ * per document type. Everything after that is the engine's: which system's map
+ * claims a note, which system's builder shapes it, which system's schema it is
+ * checked against, and which system's version stamps it.
+ *
+ * Namespaced rather than flattened, for the reason the engine barrel gives.
+ *
+ * @module
+ */
+
+/** The item-type registry: every type that compiles into an HM3 Item, and its builder. */
+export * as itemBuilders from "./item-builders.mjs";
+
+/** The `hm3:` frontmatter vocabulary of every HM3 item type. */
+export * as itemFields from "./item-fields.mjs";
+
+/** This system's note-type → document-subtype map, one-to-many rows and all (#139). */
+export * as documentSubtypes from "./document-subtypes.mjs";
+
+/** The Item compiler. */
+export * as items from "./items.mjs";
+
+/** The Actor compiler. */
+export * as actors from "./actors.mjs";
+
+/** Where HM3 records the template priority — one rule, called by both compilers. */
+export * as templatePriority from "./template-priority.mjs";
+
+// Flat as well as namespaced, matching the SoHL barrel: the default-art map is
+// the one export a Foundry runtime would import by name.
+export { HM3_DEFAULT_ITEM_ART, hm3DefaultItemArt } from "./default-item-art.mjs";