@heroiclands/package-build 17.2.0 → 18.0.0

package/hm3/item-builders.mjs

@@ -0,0 +1,84 @@
+/*
+ * 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 item-type registry** — every content type that compiles into an HM3
+ * Foundry Item, keyed to the builder that produces its `system` block.
+ *
+ * The same arrangement as `sohl/item-builders.mjs`, and a repository feeding
+ * both systems names both: `itemBuilders: [sohl, hm3]`. The engine keeps them
+ * apart from there on — `itemBuilder(type, system)` takes the system that is
+ * asking, and a type both registries declare **throws** rather than resolving
+ * when nobody says which (#58). That guard existed before there was a second
+ * registry to trip it; this is the registry it was written for.
+ *
+ * **The builders are generated, not written**, from the field declarations in
+ * `item-fields.mjs`, compiled against the `hm3` block. `buildFromFields` takes
+ * the block as an argument precisely so one declaration mechanism serves any
+ * number of systems: `data.weight` reaches `system.weightBase` under `sohl:`
+ * and `system.weight` under `hm3:`, from two declarations and one engine.
+ *
+ * **No finalizers.** SoHL has one — a combat technique's strike mode, whose
+ * *presence* depends on another field's value — and HM3 has no such
+ * conditional. The absence is worth stating: a finalizer is opaque to every
+ * reader a declaration is legible to, so having none is the state to keep.
+ *
+ * **A leaf.** It imports the declaration primitives, the field table and the
+ * art map, and never the resolved configuration — the configuration file
+ * imports *this*, so a read back out would close a cycle around the
+ * configuration's own evaluation.
+ *
+ * @module
+ */
+
+import { buildFromFields } from "../engine/field-spec.mjs";
+import { hm3DefaultItemArt } from "./default-item-art.mjs";
+import { HM3_DOCUMENT_SUBTYPES } from "./document-subtypes.mjs";
+import { HM3_ITEM_FIELDS } from "./item-fields.mjs";
+
+/**
+ * The frontmatter block these builders read.
+ *
+ * Taken from the map rather than spelled here, so the block name, the subtype
+ * map and the registry are one statement.
+ *
+ * @type {string}
+ */
+const BLOCK = HM3_DOCUMENT_SUBTYPES.block;
+
+/**
+ * Build one registry entry: the declared fields, the builder they generate, and
+ * the default art for the type.
+ *
+ * @param {string} type - The note type, and the art map's key.
+ * @returns {Readonly<{system: (fm: object) => object, img: string, fields: readonly object[]}>}
+ *   The registry entry.
+ */
+function entryFor(type) {
+    const fields = HM3_ITEM_FIELDS[type];
+    return Object.freeze({
+        system: buildFromFields(fields, { block: BLOCK }),
+        img: hm3DefaultItemArt(type),
+        fields,
+    });
+}
+
+/**
+ * Every HM3 item type, paired with the builder for its `system` block, the
+ * default art for the type, and the frontmatter fields it declares.
+ *
+ * @type {Readonly<Record<string, Readonly<{system: (fm: object) => object, img: string, fields: readonly object[]}>>>}
+ */
+export const HM3_ITEM_BUILDERS = Object.freeze(
+    Object.fromEntries(Object.keys(HM3_ITEM_FIELDS).map((type) => [type, entryFor(type)])),
+);

package/hm3/item-fields.mjs

@@ -0,0 +1,180 @@
+/*
+ * 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:` frontmatter vocabulary of every HM3 item type.
+ *
+ * The same arrangement `sohl/item-fields.mjs` describes: the declaration **is**
+ * the builder — {@link buildFromFields} turns each list into the function that
+ * runs — so a field that is not here is not emitted, and there is no second
+ * statement of the mapping to drift.
+ *
+ * **Deliberately shorter than SoHL's, and that is the honest answer.** The
+ * mapping tables in `docs/content-format.md` are the specification for what a
+ * shared `data:` fact becomes in each system, and HM3's column is `NA` far more
+ * often than SoHL's: a weapon's weight and value cross over, its quality and
+ * durability do not. Every row below is one the specification states. Where it
+ * says nothing — HM3's `armorlocation` has no `data:` row at all, and `trauma`
+ * and `mysticalability` have none either — this file declares nothing rather
+ * than inventing a plausible path. A guessed `to` compiles clean and is
+ * discarded by Foundry at load without a word, which is exactly the failure the
+ * schema check exists to catch and exactly the failure a guess would create.
+ *
+ * **One shared source, two destinations.** `name` is the shared property a
+ * field draws from and `to` is where it lands, so a single authored `weight`
+ * feeds `sohl.system.weightBase` *and* `hm3.system.weight` — one authored fact,
+ * two documents (#58). That is the whole reason the two are declared
+ * separately.
+ *
+ * The specification writes those sources as `data.weight`, and the sources here
+ * are written bare, exactly as SoHL's are: the `data:` region is #128's
+ * migration and neither half has moved to it. Spelling HM3's differently would
+ * make a note feeding both systems author the same fact twice for no gain, and
+ * would take these rows out of reach of `content-build content-format fields`,
+ * which pairs a `data.<key>` claim with a bare declared `<key>`. Both halves
+ * move together when #128 lands.
+ *
+ * **What a note authors under `hm3.system` is not declared here.** HM3 fields
+ * that no shared `data:` property feeds — a skill's `type`, an armour's
+ * `protection`, a character's `abilities` — are written at their own paths in
+ * the note's `hm3.system` block and reach the document through the verbatim
+ * passthrough. They are checked against HM3's published `schema.json` like
+ * everything else; they simply have no shared source to declare.
+ *
+ * **A leaf**, like its SoHL counterpart: declaration primitives only, never the
+ * resolved configuration.
+ *
+ * @module
+ */
+
+import { AS_AUTHORED, NUMBER } from "../engine/field-spec.mjs";
+
+/* --------------------------------------------------------------------- */
+/*  Rows shared by the four gear types                                    */
+/* --------------------------------------------------------------------- */
+
+/**
+ * What HM3's gear template takes from the shared `data:` region.
+ *
+ * `weight` and `value` are the two rows every gear table in the content format
+ * gives an HM3 destination. `quality` and `durability` are SoHL's alone — HM3
+ * carries `weaponQuality` and `armorQuality` on the subtypes that have them,
+ * which is a different fact about a different thing, so the shared row is `NA`
+ * and nothing is emitted.
+ *
+ * @type {readonly import("../engine/field-spec.mjs").FieldSpec[]}
+ */
+const GEAR_COMMON = Object.freeze([
+    {
+        name: "weight",
+        to: "weight",
+        ...AS_AUTHORED,
+        kind: "number",
+        default: 0,
+        describe: "Weight of one, in pounds.",
+    },
+    {
+        name: "value",
+        to: "value",
+        ...AS_AUTHORED,
+        kind: "number",
+        default: 0,
+        describe: "Worth of one, in pence.",
+    },
+]);
+
+/**
+ * The stack count, for the gear types whose content-format table gives it an
+ * HM3 destination.
+ *
+ * `armor`, `containergear` and `weapongear` are excluded on purpose: their
+ * tables state that quantity is always 1 and may not be authored, so the note
+ * has nothing to say and HM3's own `initial` is the right value to ship.
+ *
+ * @type {import("../engine/field-spec.mjs").FieldSpec}
+ */
+const QUANTITY = Object.freeze({
+    name: "quantity",
+    to: "quantity",
+    ...NUMBER,
+    default: 1,
+    describe: "How many the stack holds.",
+});
+
+/* --------------------------------------------------------------------- */
+/*  Per-type declarations                                                 */
+/* --------------------------------------------------------------------- */
+
+/**
+ * Every HM3 item type's frontmatter vocabulary, in the order the `system` block
+ * emits it.
+ *
+ * The keys are **note** types, not HM3 document subtypes — `projectile`
+ * rather than `missilegear`, `mysticalability` rather than `psionic` — because
+ * a registry is addressed by what a note calls itself. What the document is
+ * called is the map's answer, and only the map's.
+ *
+ * @type {Readonly<Record<string, readonly import("../engine/field-spec.mjs").FieldSpec[]>>}
+ */
+export const HM3_ITEM_FIELDS = Object.freeze({
+    armor: Object.freeze([...GEAR_COMMON]),
+
+    // The one subtype that extends the Foundry base directly, with none of the
+    // shared templates. Its content-format table has a single row, and that row
+    // is `NA` on both sides — so an armour location is authored entirely under
+    // `hm3.system` (`probWeight`, `impactType`, the per-aspect protections) and
+    // there is nothing for a shared source to feed.
+    armorlocation: Object.freeze([]),
+
+    containergear: Object.freeze([
+        ...GEAR_COMMON,
+        {
+            name: "capacity",
+            to: "capacity.max",
+            ...NUMBER,
+            default: 0,
+            describe: "How much the container holds, in pounds.",
+        },
+    ]),
+
+    miscgear: Object.freeze([...GEAR_COMMON, QUANTITY]),
+
+    // A note's `projectile` is HM3's `missilegear`; the fields are the gear
+    // template's, and the aspect, impact and range that make it a missile are
+    // authored under `hm3.system`.
+    projectile: Object.freeze([...GEAR_COMMON, QUANTITY]),
+
+    // `hm3.system.type` — "Craft", "Physical", "Communication", "Combat",
+    // "Magic", "Ritual" — has no shared source: the content format states
+    // outright that it does not map onto the note's `subType` and must be
+    // written for each HM3 skill. So it is authored at its own path and passes
+    // through, and only the mastery level is declared here.
+    skill: Object.freeze([
+        {
+            name: "masteryLevel",
+            to: "masteryLevel",
+            ...NUMBER,
+            default: 0,
+            describe: "Mastery level, as a percentage.",
+        },
+    ]),
+
+    // Both one-to-many item rows: every shared row in their content-format
+    // tables is `NA`, so what an HM3 trauma or mystical ability carries — a
+    // severity and heal rate, a convocation and level, a circle and deity — is
+    // authored under `hm3.system` against whichever subtype `hm3.type` names.
+    trauma: Object.freeze([]),
+    mysticalability: Object.freeze([]),
+
+    weapongear: Object.freeze([...GEAR_COMMON]),
+});

package/hm3/items.mjs

@@ -0,0 +1,96 @@
+/*
+ * 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 Item pass** — the two things about compiling a note into an HM3 Item
+ * that are facts about HM3 rather than about the note format (#139).
+ *
+ * Everything else is {@link module:engine/item-compiler}'s, and is the same
+ * code the SoHL pass runs: which notes are claimed, which subtype each becomes,
+ * which registry builds it, the authored `hm3.system` passthrough, the schema
+ * check, and the compendium envelope. A second system is a map and a handful of
+ * emitted keys, which is the arrangement #79 and #58 were building towards.
+ *
+ * **What HM3's compiler writes on every item: one key, and only when there is
+ * something to write.** The content format gives an item's `{#appearance}`
+ * section a home in HM3 — `description` — and SoHL none, since no SoHL Item
+ * subtype declares such a field. So the section is rendered here and nowhere
+ * else. Where a note has no such section nothing is emitted at all, which
+ * matters for `armorlocation`: it is the one HM3 subtype that extends the
+ * Foundry base directly, declaring neither `description` nor `notes`, so an
+ * unconditional key would be a finding on every armour-location document in the
+ * pack.
+ *
+ * **And one flag, for the fact HM3's `system` has no field for.** The template
+ * priority is a shared statement — a note declaring `data.templatePriority` says
+ * the same thing to both systems — but HM3 declares no `system` field for it, so
+ * it lands under this system's own flag scope as `flags.hm3.templatePriority`,
+ * exactly as the Actor pass writes it. This pass wrote no such flag until #283:
+ * an item note declaring the priority compiled into a SoHL item that knew it was
+ * a template and an HM3 item that did not.
+ *
+ * **There is no HM3 equivalent of `docHtml`.** SoHL points an item at the
+ * JournalEntry its prose compiled into, and HM3's data model has nowhere to put
+ * such a pointer; inventing one would emit a key Foundry discards at load
+ * without a word. The prose still compiles into its JournalEntry — the journals
+ * pass claims every doc-carrying type regardless of system — it simply is not
+ * addressed from the item.
+ *
+ * @module
+ */
+
+import { renderSection } from "../engine/anchored-sections.mjs";
+import { SystemItemCompiler } from "../engine/item-compiler.mjs";
+import { HM3_DOCUMENT_SUBTYPES } from "./document-subtypes.mjs";
+import { templateFlags } from "./template-priority.mjs";
+
+export class Hm3Items extends SystemItemCompiler {
+    /**
+     * 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
+     * (#58/#79).
+     *
+     * @type {import("../engine/document-subtypes.mjs").DocumentSubtypeMap}
+     */
+    static documentSubtypes = HM3_DOCUMENT_SUBTYPES;
+
+    /**
+     * The `system.*` field HM3 writes on an item from the note's prose.
+     *
+     * @param {object} fm - The note's frontmatter.
+     * @param {object} at - What the pass already knows about this note.
+     * @param {string} at.markdown - The note body, tables expanded and
+     *   wikilinks resolved.
+     * @returns {object} The shared `system` fields — `description`, or nothing.
+     */
+    commonSystem(fm, { markdown }) {
+        const description = renderSection(markdown, "appearance");
+        return description ? { description } : {};
+    }
+
+    /**
+     * The `flags` HM3 writes on an item: whatever the note authors, plus the
+     * template priority.
+     *
+     * The same statement the Actor pass records, through the same
+     * {@link module:hm3/template-priority.templateFlags} — see that module for
+     * why the priority lives in flags at all, and for what its absence here
+     * cost (#283).
+     *
+     * @param {object} fm - The note's frontmatter.
+     * @returns {object} The flags to emit.
+     */
+    commonFlags(fm) {
+        return templateFlags(fm, this.system);
+    }
+}

package/hm3/template-priority.mjs

@@ -0,0 +1,85 @@
+/*
+ * 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
+ */
+
+/**
+ * **Where HM3 records the template priority** — one statement, read by both of
+ * this system's passes (#283).
+ *
+ * `data.templatePriority` is the shared fact that a note is a *starting
+ * template*, and the specification states it as a row every type maps:
+ * `system.templatePriority` in SoHL, `flags.hm3.templatePriority` here. It lands
+ * in flags because HM3's data model declares no field for it, and an undeclared
+ * `system` key is discarded at load without a word.
+ *
+ * It was written by the Actor pass alone. The Item pass emitted only whatever
+ * `flags` the note itself authored, so an item note declaring the priority
+ * compiled into a SoHL item that knew it was a template and an HM3 item that did
+ * not — silently on both sides of the build, since an omitted flag is exactly how
+ * this system says *not a template*, making a lost priority and a deliberate one
+ * the same output. Nothing could report it either: the emitted-`system` check
+ * compares against a declared schema, and a flag is declared by nothing.
+ *
+ * So the rule lives here rather than in either pass, and both call it. Two
+ * copies of it would be two chances to diverge again, which is the failure this
+ * module exists to close.
+ *
+ * @module
+ */
+
+import log from "loglevel";
+
+import { resolveName, statedTemplatePriority } from "../engine/helpers.mjs";
+import { blockProperty } from "../engine/system-block.mjs";
+
+/**
+ * A document's `flags`: whatever the note authors, plus this system's template
+ * priority.
+ *
+ * A note that is not a template — or states nothing — writes nothing, rather
+ * than a `null` nothing reads.
+ *
+ * **Read through the shared resolver, not a field declaration** (#266). A
+ * `FieldSpec`'s shared source is a single position, and this value has five:
+ * `data:`, this block, the top level, and the retiring `archetype` spelling in
+ * the latter two. The resolver is the single implementation of what a note said,
+ * so the two systems cannot disagree about it. It is read against **this**
+ * block: the `sohl:` block is not a source for an HM3 document, so a tree that
+ * still states the priority there (`harn-ensemble`, on 2,502 notes) writes no
+ * HM3 flag until it sweeps to `data:`.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {string} block - This pass's system block.
+ * @returns {object} The flags to emit.
+ */
+export function templateFlags(fm, block) {
+    const authored = blockProperty(fm, block, "flags", {});
+    const stated = statedTemplatePriority(fm, resolveName(fm), { block });
+    if (stated == null) return authored;
+    // Coerced, as the field declaration this replaced coerced it: a note may
+    // state the priority as a YAML string, and `"3"` is a priority.
+    const value = Number(stated);
+    if (!Number.isFinite(value)) {
+        log.warn(
+            `${resolveName(fm)}: template priority ${JSON.stringify(stated)} is ` +
+                `not a number; no template flag written.`,
+        );
+        return authored;
+    }
+    return {
+        ...authored,
+        [block]: {
+            .../** @type {Record<string, unknown>} */ (authored)[block],
+            templatePriority: value,
+        },
+    };
+}

package/manifest.mjs

@@ -53,6 +53,7 @@ import fsSync from "node:fs";
 import path from "node:path";
 
 import { emitDiagnostic, positionOfYamlPath } from "./engine/diagnostics.mjs";
+import { metadataFileName } from "./engine/metadata-index.mjs";
 
 /**
  * The two package kinds Foundry defines, as the artifact name each one's
@@ -97,7 +98,7 @@ export function normalizeRepoUrl(repository) {
 }
 
 /**
- * The four addresses a Foundry manifest advertises.
+ * The addresses a Foundry manifest advertises.
  *
  * `manifest` deliberately points at **`releases/latest`** rather than at this
  * version: it is the URL an *installed* package re-fetches to discover that a
@@ -120,6 +121,26 @@ export function releaseUrls({ repoUrl, version, artifact }) {
     };
 }
 
+/**
+ * Where this release publishes its content index (#239).
+ *
+ * **Pinned to this version, like `download` and unlike `manifest`.** A
+ * consumer reaches this URL by reading the dependency's manifest, so the
+ * manifest it read and the index it then fetches describe the same release —
+ * which is the whole point of publishing them together. A `releases/latest`
+ * index would silently pair a pinned manifest with a moving index, and the
+ * mismatch would surface as a cross-package link that resolved yesterday.
+ *
+ * @param {object} opts
+ * @param {string} opts.repoUrl - Normalised repository URL.
+ * @param {string} opts.version - The version being built.
+ * @param {string} opts.contentPackage - The content package name.
+ * @returns {string} The version-pinned asset URL.
+ */
+export function metadataUrl({ repoUrl, version, contentPackage }) {
+    return `${repoUrl}/releases/download/v${version}/${metadataFileName(contentPackage)}`;
+}
+
 /**
  * The order the manifest's keys are written in.
  *
@@ -455,8 +476,28 @@ export function buildManifest({ config, packageJson, artifact, flags }) {
 
     const merged = { ...declared, ...derived };
 
+    // The index every consumer resolves this package's addresses through
+    // (#239). Written unconditionally, because a package that publishes no
+    // index is one nothing can link into — and the failure of an absent one is
+    // a dead link in somebody else's build, which is exactly the kind of
+    // silence this replaced the vendored manifest to end.
+    //
+    // A flag rather than a top-level key because Foundry's manifest schema is
+    // closed and `flags` is its declared extension point; an unknown key at the
+    // top level is dropped by some readers and rejected by others.
+    if (config.contentPackage) {
+        merged.flags = {
+            ...(declared.flags ?? {}),
+            metadataUrl: metadataUrl({
+                repoUrl,
+                version: packageJson.version,
+                contentPackage: config.contentPackage,
+            }),
+        };
+    }
+
     if (flags && Object.keys(flags).length) {
-        merged.flags = { ...(declared.flags ?? {}) };
+        merged.flags = { ...(merged.flags ?? declared.flags ?? {}) };
         for (const [namespace, values] of Object.entries(flags)) {
             merged.flags[namespace] = {
                 ...(declared.flags?.[namespace] ?? {}),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "17.2.0",
+    "version": "18.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",
@@ -27,6 +27,14 @@
             "types": "./types/sohl/*.d.mts",
             "import": "./sohl/*.mjs"
         },
+        "./hm3": {
+            "types": "./types/hm3/index.d.mts",
+            "import": "./hm3/index.mjs"
+        },
+        "./hm3/*": {
+            "types": "./types/hm3/*.d.mts",
+            "import": "./hm3/*.mjs"
+        },
         "./content-config": {
             "types": "./types/content-config.d.mts",
             "import": "./content-config.mjs"
@@ -105,6 +113,7 @@
         "deploy.mjs",
         "e2e.mjs",
         "engine",
+        "hm3",
         "index.mjs",
         "lang.mjs",
         "labels.mjs",
@@ -118,11 +127,14 @@
         "types"
     ],
     "dependencies": {
+        "@duckdb/node-api": "^1.5.5-r.4",
         "@foundryvtt/foundryvtt-cli": "^3.0.4",
         "acorn": "^8.18.0",
         "archiver": "^8.0.0",
         "classic-level": "^3.0.0",
         "dotenv": "^17.2.3",
+        "eslint": "^10.10.0",
+        "eslint-plugin-yml": "^3.8.1",
         "fflate": "^0.8.3",
         "glob": "^13.0.6",
         "gray-matter": "^4.0.3",
@@ -150,12 +162,14 @@
         "build:types": "tsc -p tsconfig.dts.json",
         "format": "prettier --write .",
         "format:check": "prettier --check .",
-        "lint": "npm run format:check && npm run lint:markdown && npm run lint:content-format",
+        "lint": "npm run format:check && npm run lint:markdown && npm run lint:yaml && npm run lint:labels && npm run lint:content-format",
         "lint:markdown": "node bin/content-build.mjs markdown",
+        "lint:yaml": "node bin/package-build.mjs yaml",
+        "lint:labels": "node bin/package-build.mjs labels check",
         "lint:markdown:fix": "node bin/content-build.mjs markdown --fix",
         "lint:content-format": "npm run lint:content-format:schema && npm run lint:content-format:fields",
-        "lint:content-format:schema": "node bin/content-build.mjs content-format schema --schema sohl=tests/fixtures/content-format/schema-sohl.json",
-        "lint:content-format:fields": "node bin/content-build.mjs content-format fields --fields sohl",
+        "lint:content-format:schema": "node bin/content-build.mjs content-format schema --schema sohl=tests/fixtures/content-format/schema-sohl.json --schema hm3=tests/fixtures/content-format/schema-hm3.json",
+        "lint:content-format:fields": "node bin/content-build.mjs content-format fields --fields sohl && node bin/content-build.mjs content-format fields --fields hm3",
         "changeset": "changeset",
         "changeset:check": "changeset status --since=origin/main",
         "changeset:version": "changeset version && npm install --package-lock-only",