@heroiclands/package-build 8.1.0 → 10.0.0

package/engine/wikilinks.mjs

@@ -16,11 +16,17 @@
  *
  * Content notes link to one another with wikilinks rather than file paths:
  *
- *   `[[type/shortcode|Text]]`   a document of that type
+ *   `[[type-shortcode|Text]]`   a document of that type
+ *   `[[type-shortcode|]]`       the same, showing the target's current name
  *   `[[Text]]`                  an alias unique within the source's own type
- *   `[[type/shortcode#slug|T]]` a section (see below)
+ *   `[[type-shortcode#slug|T]]` a section (see below)
  *   `[[#slug|Text]]`            a section of the source note itself
- *   `[[doctype/shortcode|T]]`   an item's *documentation* (see below)
+ *   `[[doctype-shortcode|T]]`   an item's *documentation* (see below)
+ *
+ * **The pipe decides which of the two namespaces a target belongs to** (#131),
+ * and neither falls back to the other — see {@link resolvesAsAddress}, which
+ * states the rule for both builds. A piped target is parsed by the address
+ * grammar; an unpiped one is looked up in the alias index.
  *
  * The qualifier is the note's **type**, which with its shortcode is the system's
  * logical identity: `(type, shortcode)` is unique by rule (see the Shortcode
@@ -28,13 +34,13 @@
  * unique per type, not per directory, so a directory qualifier would add nothing
  * to the address while breaking every inbound link the moment a note is refiled.
  *
- * The bare form is the same address with the qualifier left implicit: it resolves
- * against the aliases of the source's **own type**, so a `doc` reaches any other
- * `doc` by name wherever it is filed. Nothing narrower is consulted — a note's
+ * The bare form is a **name**, not an abbreviated address: it resolves against
+ * the aliases of the source's **own type**, so a `doc` reaches any other `doc`
+ * by name wherever it is filed. Nothing narrower is consulted — a note's
  * directory and its `category` play no part in resolution. Where two notes of a
  * type legitimately share a name (a rules page and a user-guide page both called
  * "Gear"), the bare form is ambiguous and resolves to neither; the author writes
- * the full `[[type/shortcode|Text]]` form instead.
+ * the `[[type-shortcode|Text]]` address instead.
  *
  * At compile time each becomes a Foundry UUID enricher, routed to the pack that
  * the target's type compiles into (see {@link packForType}):
@@ -82,18 +88,15 @@
 
 import crypto from "crypto";
 
-import {
-    compendiumUuid,
-    ITEM_PACK,
-    packForType,
-    pageUuid,
-    PACK_BY_TYPE,
-} from "./ids.mjs";
+import { compendiumUuid, ITEM_PACK, packForType, pageUuid, PACK_BY_TYPE } from "./ids.mjs";
 import { hasDocEntry, itemDocEntryId } from "./item-docs.mjs";
 import { replaceOutsideCode } from "./code-fences.mjs";
 // The syntax lives in `./wikilink-syntax.mjs`, so the web resolver and this
 // one cannot disagree about what counts as a link.
-import { authoredLabel, WIKILINK, parseWikilink } from "./wikilink-syntax.mjs";
+import { authoredLabel, WIKILINK, parseWikilink, resolvesAsAddress } from "./wikilink-syntax.mjs";
+// The alias half of the two namespaces: what may be claimed, and how a claim
+// is keyed. Shared with the site build and the link checker (#131).
+import { aliasKey } from "./alias-index.mjs";
 
 export { ITEM_PACK, PACK_BY_TYPE, packForType };
 
@@ -194,11 +197,7 @@ export function readQualifier(target, types, packages) {
 
     const slash = target.lastIndexOf("/");
     if (slash > 0) {
-        const read = readTypeAndCode(
-            target.slice(0, slash),
-            target.slice(slash + 1),
-            types,
-        );
+        const read = readTypeAndCode(target.slice(0, slash), target.slice(slash + 1), types);
         // A slash means qualified whether or not the type is real.
         return read ?? { reason: "unknown-type" };
     }
@@ -206,11 +205,7 @@ export function readQualifier(target, types, packages) {
     const hyphen = target.indexOf("-");
     if (hyphen > 0) {
         // A hyphen qualifies only on a known type; otherwise it is part of a name.
-        return readTypeAndCode(
-            target.slice(0, hyphen),
-            target.slice(hyphen + 1),
-            types,
-        );
+        return readTypeAndCode(target.slice(0, hyphen), target.slice(hyphen + 1), types);
     }
     return null;
 }
@@ -313,23 +308,14 @@ export function buildWikilinkIndex(docs, packageId, foreign, contentPackage) {
             // An item's prose compiles into a separate JournalEntry, addressed
             // by the virtual `doc<type>` qualifier. Its id is derived from the
             // item's, so its address is knowable here too.
-            docUuid: compendiumUuid(
-                packageId,
-                "doc",
-                itemDocEntryId(d.id),
-                d.docPack,
-            ),
+            docUuid: compendiumUuid(packageId, "doc", itemDocEntryId(d.id), d.docPack),
         });
 
-        if (d.shortcode)
-            byShortcode.set(`${norm(d.type)}/${norm(d.shortcode)}`, d);
+        if (d.shortcode) byShortcode.set(`${norm(d.type)}/${norm(d.shortcode)}`, d);
         for (const a of d.aliases ?? []) {
-            const key = `${norm(d.type)}|${norm(a)}`;
+            const key = aliasKey(d.type, a);
             // Second claimant poisons the alias: it can no longer be resolved.
-            byAlias.set(
-                key,
-                byAlias.has(key) && byAlias.get(key) !== d ? null : d,
-            );
+            byAlias.set(key, byAlias.has(key) && byAlias.get(key) !== d ? null : d);
             // Every claimant is kept alongside, because poisoning the alias
             // discards exactly the information needed to report the problem.
             // The note that *cites* an ambiguous alias is innocent — whoever
@@ -411,11 +397,7 @@ function findForeign(index, read) {
     const wanted = norm(read.itemDoc ? `doc${read.type}` : read.type);
     const shortcode = norm(read.shortcode);
     if (read.package) {
-        return (
-            index.foreign.get(
-                `${read.package}-${wanted}-${shortcode}`.toLowerCase(),
-            ) ?? null
-        );
+        return index.foreign.get(`${read.package}-${wanted}-${shortcode}`.toLowerCase()) ?? null;
     }
     const hits = [];
     for (const [key, v] of index.foreign) {
@@ -490,159 +472,141 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
     // `offset` is the third replacer argument because the pattern has exactly
     // one capture group. It is what makes two identical unresolved links on
     // one note tellable apart, and a position reportable at all (#17).
-    const out = replaceOutsideCode(
-        markdown,
-        WIKILINK,
-        (all, rawInner, offset) => {
-            const parsed = parseWikilink(rawInner);
-            const { labelled } = parsed;
-            let target = parsed.target;
-            // An unlabelled link shows its interior verbatim, anchor included;
-            // a labelled one shows its label. An *empty* label is not a label
-            // — `[[x|]]` means "show the target's name" — and that reading
-            // comes from {@link authoredLabel} so the web resolver cannot draw
-            // the line somewhere else (#113).
-            let text = labelled ? (authoredLabel(parsed) ?? "") : parsed.inner;
-            const slug = parsed.anchor || null;
+    const out = replaceOutsideCode(markdown, WIKILINK, (all, rawInner, offset) => {
+        const parsed = parseWikilink(rawInner);
+        const { labelled } = parsed;
+        let target = parsed.target;
+        // An unlabelled link shows its interior verbatim, anchor included;
+        // a labelled one shows its label. An *empty* label is not a label
+        // — `[[x|]]` means "show the target's name" — and that reading
+        // comes from {@link authoredLabel} so the web resolver cannot draw
+        // the line somewhere else (#113).
+        let text = labelled ? (authoredLabel(parsed) ?? "") : parsed.inner;
+        const slug = parsed.anchor || null;
 
-            // Resolve the document: same-page (empty target), type-shortcode, or alias.
-            let doc;
-            // Set when the qualifier was the virtual `doc<type>` form, so the UUID
-            // is built against the item doc entry rather than the item itself.
-            let itemDoc = false;
-            // Set when the target was read as `type-shortcode` — an address rather
-            // than prose, which decides what an unlabelled link shows (#1409).
-            let addressed = false;
-            // Kept for the foreign fallback below, which needs the parsed address.
-            let qualifiedRead = null;
-            if (target === "" && slug) {
-                doc = { type, id, pack, docPack };
-            } else {
-                const qualified = readQualifier(
+        // Resolve the document: same-page (empty target), an address, or an
+        // alias. **The pipe chooses which**, with no fallback either way
+        // (#131) — see {@link resolvesAsAddress}.
+        let doc;
+        // Set when the qualifier was the virtual `doc<type>` form, so the UUID
+        // is built against the item doc entry rather than the item itself.
+        let itemDoc = false;
+        // Set when the target was read as an address, which is what decides
+        // whether a foreign manifest is consulted for it below.
+        let addressed = false;
+        // Kept for the foreign fallback below, which needs the parsed address.
+        let qualifiedRead = null;
+        if (target === "" && slug) {
+            doc = { type, id, pack, docPack };
+        } else if (resolvesAsAddress(parsed)) {
+            const qualified = readQualifier(target, index.types, index.packages);
+            qualifiedRead = qualified;
+            // The author wrote a pipe, so they meant an address. A target that
+            // does not parse as one is therefore a defect and not, as it was
+            // under the old resolve-by-shape rule, an invitation to try the
+            // alias index — which is what let a note *name* resolve here.
+            if (!qualified || qualified.reason) {
+                unresolved.push({
+                    link: all,
                     target,
-                    index.types,
-                    index.packages,
-                );
-                qualifiedRead = qualified;
-                if (qualified?.reason) {
-                    unresolved.push({
-                        link: all,
-                        target,
-                        offset,
-                        reason: qualified.reason,
-                    });
-                    return unresolvedLink(text || target, target);
-                }
-                if (qualified) {
-                    addressed = true;
-                    itemDoc = qualified.itemDoc;
-                    doc = index.byShortcode.get(
-                        `${qualified.type}/${qualified.shortcode}`,
-                    );
-                } else {
-                    const aliasKey = `${norm(type)}|${norm(target)}`;
-                    const hit = index.byAlias.get(aliasKey);
-                    if (hit === null) {
-                        unresolved.push({
-                            link: all,
-                            target,
-                            offset,
-                            reason: "ambiguous",
-                            // Who claimed it, so the report can name the collision
-                            // rather than the note that merely cites it (#13).
-                            candidates: (
-                                index.aliasClaims?.get(aliasKey) ?? []
-                            ).map((d) => ({
-                                type: d.type,
-                                shortcode: d.shortcode,
-                                name: d.name,
-                            })),
-                        });
-                        return unresolvedLink(text || target, target);
-                    }
-                    doc = hit;
-                }
+                    offset,
+                    reason: qualified?.reason ?? "not-an-address",
+                    addressed: true,
+                });
+                return unresolvedLink(text || target, target);
             }
-            if (!doc) {
-                // Nothing local answers. A foreign package may publish this
-                // address, in which case the manifest hands back a complete UUID —
-                // including, for a section link, the anchor's own — so nothing is
-                // derived here.
-                const hit = findForeign(index, qualifiedRead);
-                if (hit) {
-                    const uuid = slug ? hit.anchors?.[slug] : hit.uuid;
-                    if (uuid) {
-                        return `@UUID[${uuid}]{${text || hit.name || target}}`;
-                    }
-                    unresolved.push({
-                        link: all,
-                        target,
-                        offset,
-                        reason: "unknown-anchor",
-                        addressed: true,
-                    });
-                    return unresolvedLink(text || target, target);
+            addressed = true;
+            itemDoc = qualified.itemDoc;
+            doc = index.byShortcode.get(`${qualified.type}/${qualified.shortcode}`);
+        } else {
+            const key = aliasKey(type, target);
+            const hit = index.byAlias.get(key);
+            if (hit === null) {
+                unresolved.push({
+                    link: all,
+                    target,
+                    offset,
+                    reason: "ambiguous",
+                    // Who claimed it, so the report can name the collision
+                    // rather than the note that merely cites it (#13).
+                    candidates: (index.aliasClaims?.get(key) ?? []).map((d) => ({
+                        type: d.type,
+                        shortcode: d.shortcode,
+                        name: d.name,
+                    })),
+                });
+                return unresolvedLink(text || target, target);
+            }
+            doc = hit;
+        }
+        if (!doc) {
+            // Nothing local answers. A foreign package may publish this
+            // address, in which case the manifest hands back a complete UUID —
+            // including, for a section link, the anchor's own — so nothing is
+            // derived here.
+            const hit = findForeign(index, qualifiedRead);
+            if (hit) {
+                const uuid = slug ? hit.anchors?.[slug] : hit.uuid;
+                if (uuid) {
+                    return `@UUID[${uuid}]{${text || hit.name || target}}`;
                 }
                 unresolved.push({
                     link: all,
                     target,
                     offset,
-                    reason: "unknown",
-                    // A *qualified* address that resolves nowhere is a typo: every
-                    // package it could name is either built here or vendored, so
-                    // there is no third possibility left. A bare alias is not — it
-                    // may simply be prose.
-                    addressed: !!qualifiedRead && !qualifiedRead.reason,
+                    reason: "unknown-anchor",
+                    addressed: true,
                 });
                 return unresolvedLink(text || target, target);
             }
+            unresolved.push({
+                link: all,
+                target,
+                offset,
+                reason: "unknown",
+                // An *address* that resolves nowhere is a typo: every package
+                // it could name is either built here or vendored, so there is
+                // no third possibility left. A bare alias is not — it may
+                // simply be prose, or a worldbuilding placeholder.
+                addressed,
+            });
+            return unresolvedLink(text || target, target);
+        }
 
-            // With no explicit label, a *qualified* target has no prose to show — a
-            // shortcode is an address, not display text — so the document's own name
-            // stands in (#1409). A bare `[[Text]]` is already the prose the author
-            // wrote, and substituting the canonical name there would rewrite the
-            // sentence ("worsens the [[Shock State]]" must not render as "Shock").
-            // The knowledgebase build reads the same authored link the same way.
-            if (!text || (!labelled && addressed)) text = doc.name ?? target;
+        // An address with no label — `[[skill-clmb|]]` — has no prose to show,
+        // a shortcode being an address rather than display text, so the
+        // document's **current** name stands in and a rename shows at every
+        // citation with no link edited (#1409, #131). A bare `[[Text]]` is
+        // already the prose the author wrote, and substituting the canonical
+        // name there would rewrite the sentence ("worsens the [[Shock State]]"
+        // must not render as "Shock"). The knowledgebase build reads the same
+        // authored link the same way.
+        if (!text) text = doc.name ?? target;
 
-            // Both addresses were computed when the target was indexed. An item
-            // doc lives in the journals pack under its own derived entry id, and
-            // its pages hash against *that* id — not the item's.
-            //
-            // The one target with no index entry is the note itself: a `[[#slug]]`
-            // self-link is resolved from the source's own type and id, which the
-            // caller supplied, so it is addressed the same way here.
-            const addresses = index.uuidByDoc.get(doc) ?? {
-                uuid: compendiumUuid(
-                    index.packageId,
-                    doc.type,
-                    doc.id,
-                    doc.pack,
-                ),
-                docUuid: compendiumUuid(
-                    index.packageId,
-                    "doc",
-                    itemDocEntryId(doc.id),
-                    doc.docPack,
-                ),
-            };
-            const entryUuid = itemDoc ? addresses.docUuid : addresses.uuid;
-            const entryId = itemDoc ? itemDocEntryId(doc.id) : doc.id;
-            const isJournal =
-                itemDoc || packForType(doc.type).docType === "JournalEntry";
-            // A JournalEntry link opens a journal — at its first page, or at the
-            // page an anchor names. An Item or Actor link opens that document's
-            // *sheet*, which has no sections, so the anchor has nothing to address
-            // and is dropped. Forging a JournalEntryPage id onto a document that
-            // can never hold one is what made such links dead-end (#1362); an
-            // item's pages are addressed through its `doc<type>` counterpart.
-            const uuid =
-                slug && isJournal ?
-                    pageUuid(entryUuid, anchorPageId(entryId, slug))
-                :   entryUuid;
-            return `@UUID[${uuid}]{${text}}`;
-        },
-    );
+        // Both addresses were computed when the target was indexed. An item
+        // doc lives in the journals pack under its own derived entry id, and
+        // its pages hash against *that* id — not the item's.
+        //
+        // The one target with no index entry is the note itself: a `[[#slug]]`
+        // self-link is resolved from the source's own type and id, which the
+        // caller supplied, so it is addressed the same way here.
+        const addresses = index.uuidByDoc.get(doc) ?? {
+            uuid: compendiumUuid(index.packageId, doc.type, doc.id, doc.pack),
+            docUuid: compendiumUuid(index.packageId, "doc", itemDocEntryId(doc.id), doc.docPack),
+        };
+        const entryUuid = itemDoc ? addresses.docUuid : addresses.uuid;
+        const entryId = itemDoc ? itemDocEntryId(doc.id) : doc.id;
+        const isJournal = itemDoc || packForType(doc.type).docType === "JournalEntry";
+        // A JournalEntry link opens a journal — at its first page, or at the
+        // page an anchor names. An Item or Actor link opens that document's
+        // *sheet*, which has no sections, so the anchor has nothing to address
+        // and is dropped. Forging a JournalEntryPage id onto a document that
+        // can never hold one is what made such links dead-end (#1362); an
+        // item's pages are addressed through its `doc<type>` counterpart.
+        const uuid =
+            slug && isJournal ? pageUuid(entryUuid, anchorPageId(entryId, slug)) : entryUuid;
+        return `@UUID[${uuid}]{${text}}`;
+    });
 
     return { markdown: out, unresolved };
 }

package/index.mjs

@@ -42,11 +42,7 @@
 // ── Content: notes to compendium packs, site content, link manifests ────────
 
 /** The configuration contract a consuming repository declares its build with. */
-export {
-    defineConfig,
-    PACKAGE_KINDS,
-    PACK_DOCUMENT_TYPES,
-} from "./content-config.mjs";
+export { defineConfig, PACKAGE_KINDS, PACK_DOCUMENT_TYPES } from "./content-config.mjs";
 
 /** The content pipeline — walking, compiling, linking, emitting. */
 export * as engine from "./engine/index.mjs";

package/lang.mjs

@@ -116,9 +116,7 @@ export function validateLangSource(raw) {
     } catch (err) {
         // Nothing further can be said about a file that does not parse, and
         // guessing at its intended shape would only bury this finding.
-        return [
-            { severity: "error", message: `not valid JSON: ${err.message}` },
-        ];
+        return [{ severity: "error", message: `not valid JSON: ${err.message}` }];
     }
 
     if (!isRecord(json)) {

package/manifest.mjs

@@ -81,8 +81,7 @@ export const ARTIFACTS = Object.freeze(["system", "module"]);
  *   worse than a missing one: Foundry installs it and never offers an update.
  */
 export function normalizeRepoUrl(repository) {
-    const raw =
-        typeof repository === "string" ? repository : (repository?.url ?? "");
+    const raw = typeof repository === "string" ? repository : (repository?.url ?? "");
     const url = String(raw)
         .trim()
         .replace(/^git\+/, "")
@@ -177,10 +176,7 @@ const MANIFEST_KEY_ORDER = Object.freeze([
  * @returns {object[]} The manifest's `packs` array.
  */
 export function manifestPacks(config) {
-    const flatten = (pack) => [
-        pack,
-        ...(pack.companions ?? []).flatMap(flatten),
-    ];
+    const flatten = (pack) => [pack, ...(pack.companions ?? []).flatMap(flatten)];
     return config.packs.flatMap(flatten).map((pack) => {
         // Foundry requires `system` on ActiveEffect, Actor and Item packs and
         // on no others, so the value is per pack: its own declaration first,
@@ -205,11 +201,7 @@ export function manifestPacks(config) {
  *
  * @type {readonly string[]}
  */
-const PACK_FOLDERS_PATH = Object.freeze([
-    "packageBuild",
-    "manifest",
-    "packFolders",
-]);
+const PACK_FOLDERS_PATH = Object.freeze(["packageBuild", "manifest", "packFolders"]);
 
 /**
  * Every pack name a folder tree names, with the folder that named it.
@@ -371,8 +363,7 @@ export const BUILD_ONLY_RELATIONSHIP_KEYS = Object.freeze(["itemCatalog"]);
 export function publishedRelationships(relationships) {
     const published = {};
     for (const [kind, entries] of Object.entries(relationships)) {
-        published[kind] =
-            Array.isArray(entries) ? entries.map(withoutBuildKeys) : entries;
+        published[kind] = Array.isArray(entries) ? entries.map(withoutBuildKeys) : entries;
     }
     return published;
 }
@@ -388,9 +379,7 @@ function withoutBuildKeys(entry) {
         return entry;
     }
     return Object.fromEntries(
-        Object.entries(entry).filter(
-            ([key]) => !BUILD_ONLY_RELATIONSHIP_KEYS.includes(key),
-        ),
+        Object.entries(entry).filter(([key]) => !BUILD_ONLY_RELATIONSHIP_KEYS.includes(key)),
     );
 }
 
@@ -447,23 +436,18 @@ export function buildManifest({ config, packageJson, artifact, flags }) {
         const entry = {
             id: config.requiresSystem,
             type: "system",
-            ...(declaredSystem?.manifest ?
-                { manifest: declaredSystem.manifest }
-            :   {}),
+            ...(declaredSystem?.manifest ? { manifest: declaredSystem.manifest } : {}),
             ...(declaredSystem?.compatibility ?
                 {
                     compatibility: Object.fromEntries(
-                        Object.entries(declaredSystem.compatibility).filter(
-                            ([, v]) => v != null,
-                        ),
+                        Object.entries(declaredSystem.compatibility).filter(([, v]) => v != null),
                     ),
                 }
             :   {}),
         };
         // An explicit `relationships.systems` still wins, so a repository
         // mid-migration is never told two different things about itself.
-        relationships.systems =
-            relationships.systems?.length ? relationships.systems : [entry];
+        relationships.systems = relationships.systems?.length ? relationships.systems : [entry];
     }
     if (Object.keys(relationships).length) {
         derived.relationships = publishedRelationships(relationships);
@@ -553,14 +537,7 @@ function reportPackFolders(findings, configFile) {
  * @throws {Error} When a `packFolders` entry names a pack the package does not
  *   ship. Nothing is written in that case.
  */
-export async function writeManifest({
-    config,
-    packageJson,
-    artifact,
-    outDir,
-    flags,
-    configFile,
-}) {
+export async function writeManifest({ config, packageJson, artifact, outDir, flags, configFile }) {
     const manifest = buildManifest({ config, packageJson, artifact, flags });
 
     const errors = reportPackFolders(
@@ -583,10 +560,6 @@ export async function writeManifest({
     const outPath = path.join(outDir, `${artifact}.json`);
     // Trailing newline: the file is committed to a release archive and read by
     // humans as often as by Foundry.
-    await fs.writeFile(
-        outPath,
-        `${JSON.stringify(manifest, null, 2)}\n`,
-        "utf8",
-    );
+    await fs.writeFile(outPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
     return { path: outPath, manifest };
 }

package/markdownlint-config.mjs

@@ -31,11 +31,7 @@
  * @module
  */
 
-import {
-    MARKDOWNLINT_CONFIG,
-    MARKDOWN_GLOBS,
-    MARKDOWN_IGNORES,
-} from "./engine/prose-config.mjs";
+import { MARKDOWNLINT_CONFIG, MARKDOWN_GLOBS, MARKDOWN_IGNORES } from "./engine/prose-config.mjs";
 
 export default {
     config: MARKDOWNLINT_CONFIG,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "8.1.0",
+    "version": "10.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",
@@ -101,6 +101,7 @@
         "container.mjs",
         "content-config.mjs",
         "coverage.mjs",
+        "docs",
         "deploy.mjs",
         "e2e.mjs",
         "engine",
@@ -148,9 +149,12 @@
         "build:types": "tsc -p tsconfig.dts.json",
         "format": "prettier --write .",
         "format:check": "prettier --check .",
-        "lint": "npm run format:check && npm run lint:markdown",
+        "lint": "npm run format:check && npm run lint:markdown && npm run lint:content-format",
         "lint:markdown": "node bin/content-build.mjs markdown",
         "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",
         "changeset": "changeset",
         "changeset:check": "changeset status --since=origin/main",
         "changeset:version": "changeset version && npm install --package-lock-only",