@heroiclands/package-build 8.0.0 → 9.0.0

package/engine/wikilinks.mjs

@@ -82,13 +82,7 @@
 
 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
@@ -194,11 +188,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 +196,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 +299,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)}`;
             // 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 +388,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 +463,134 @@ 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), 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(target, index.types, index.packages);
+            qualifiedRead = qualified;
+            if (qualified?.reason) {
+                unresolved.push({
+                    link: all,
                     target,
-                    index.types,
-                    index.packages,
-                );
-                qualifiedRead = qualified;
-                if (qualified?.reason) {
+                    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: qualified.reason,
+                        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);
                 }
-                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;
-                }
+                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-anchor",
-                        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",
-                    // 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",
+                // 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,
+            });
+            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;
+        // 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;
 
-            // 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.0.0",
+    "version": "9.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",

package/sohl/actors.mjs

@@ -151,9 +151,7 @@ function extractBodyAndMovement(fm) {
     return {
         body: normalizeBody(sohlField(fm, "body", {})),
         currentMoveMedium: String(sohlField(fm, "currentMoveMedium", "none")),
-        movementProfiles: normalizeMovementProfiles(
-            sohlField(fm, "movementProfiles", []),
-        ),
+        movementProfiles: normalizeMovementProfiles(sohlField(fm, "movementProfiles", [])),
     };
 }
 
@@ -290,8 +288,7 @@ function extractAnchorSection(body, anchorId) {
             if (capturing) captured.push(line);
             continue;
         }
-        const h1Match =
-            !inCodeBlock ? line.match(/^\s*#\s+(.+?)\s*#*\s*$/) : null;
+        const h1Match = !inCodeBlock ? line.match(/^\s*#\s+(.+?)\s*#*\s*$/) : null;
         if (h1Match) {
             const anchor = h1Match[1].match(/\{#([^}]+)\}\s*$/);
             const id = anchor?.[1]?.trim().toLowerCase() || null;
@@ -383,13 +380,8 @@ export class Actors extends BasePackCompiler {
      */
     async prepare() {
         await super.prepare();
-        this.itemsMap = loadItemsMap(
-            this.itemsSourceDirs,
-            this.foreignSourceDirs,
-        );
-        log.info(
-            `Loaded ${this.itemsMap.size} predefined items for actor resolution`,
-        );
+        this.itemsMap = loadItemsMap(this.itemsSourceDirs, this.foreignSourceDirs);
+        log.info(`Loaded ${this.itemsMap.size} predefined items for actor resolution`);
     }
 
     /**
@@ -421,22 +413,12 @@ export class Actors extends BasePackCompiler {
      * `(actorId, type, shortcode, indexKey)` so re-exports are stable.
      * Returns null if the descriptor cannot be resolved.
      */
-    resolveEmbedded(
-        itemsMap,
-        actorId,
-        type,
-        shortcode,
-        overlay,
-        indexKey,
-        ctx,
-    ) {
+    resolveEmbedded(itemsMap, actorId, type, shortcode, overlay, indexKey, ctx) {
         let base = null;
         if (shortcode) {
             base = itemsMap.get(`${type}:${shortcode}`);
             if (!base) {
-                this.noteError(
-                    `${ctx}: no predefined item for "${type}:${shortcode}"`,
-                );
+                this.noteError(`${ctx}: no predefined item for "${type}:${shortcode}"`);
                 this.errorCount++;
                 return null;
             }
@@ -452,10 +434,7 @@ export class Actors extends BasePackCompiler {
         }
         const merged = overlay ? deepMerge(base, overlay) : base;
         merged.type = type;
-        merged._id = makeId(
-            actorId,
-            `${type}:${shortcode || merged.name}:${indexKey}`,
-        );
+        merged._id = makeId(actorId, `${type}:${shortcode || merged.name}:${indexKey}`);
         // Foundry's pack compiler flattens the document hierarchy into LevelDB,
         // storing each embedded document under its own `_key`. Embedded items
         // therefore need a hierarchical key, as do any effects they carry
@@ -499,9 +478,7 @@ export class Actors extends BasePackCompiler {
         if (Array.isArray(sohlItems)) {
             sohlItems.forEach((entry, index) => {
                 if (!entry || typeof entry !== "object") {
-                    this.noteError(
-                        `${ctx}: sohl.items[${index}] is not an object`,
-                    );
+                    this.noteError(`${ctx}: sohl.items[${index}] is not an object`);
                     this.errorCount++;
                     return;
                 }
@@ -556,10 +533,7 @@ export class Actors extends BasePackCompiler {
      */
     openUnopenedSkills(items, ctx) {
         const skills = items.filter(
-            (item) =>
-                item.type === "skill" &&
-                item.system &&
-                item.system.masteryLevelBase == null,
+            (item) => item.type === "skill" && item.system && item.system.masteryLevelBase == null,
         );
         if (!skills.length) return;
 
@@ -621,11 +595,7 @@ export class Actors extends BasePackCompiler {
         }
 
         // Being-only combat grouping (mirrors `system.defaultCombatGroup`).
-        const defaultCombatGroup = sohlField(
-            fm,
-            "defaultCombatGroup",
-            undefined,
-        );
+        const defaultCombatGroup = sohlField(fm, "defaultCombatGroup", undefined);
         if (defaultCombatGroup !== undefined) {
             system.defaultCombatGroup = defaultCombatGroup;
         }

package/sohl/being-info.mjs

@@ -108,8 +108,7 @@ export function deriveBeingInfo(sohl, index) {
     const items = Array.isArray(out.items) ? out.items : [];
     if (items.length === 0) return out;
 
-    const lookup = (type, shortcode) =>
-        shortcode ? index.get(`${type}:${shortcode}`) : undefined;
+    const lookup = (type, shortcode) => (shortcode ? index.get(`${type}:${shortcode}`) : undefined);
 
     /** An item's display name: its own, then the index's, then its shortcode. */
     const displayName = (it, ref, shortcode) =>
@@ -135,8 +134,7 @@ export function deriveBeingInfo(sohl, index) {
             if (!isMap(it)) continue;
             const key = GEAR_TYPE_TO_KEY[it.type];
             if (!key) continue;
-            const shortcode =
-                typeof it.shortcode === "string" ? it.shortcode : undefined;
+            const shortcode = typeof it.shortcode === "string" ? it.shortcode : undefined;
             const ref = lookup(it.type, shortcode);
             const name = displayName(it, ref, shortcode);
             if (!name) continue;
@@ -153,8 +151,7 @@ export function deriveBeingInfo(sohl, index) {
     const talents = [];
     for (const it of items) {
         if (!isMap(it) || it.type !== "mysticalability") continue;
-        const shortcode =
-            typeof it.shortcode === "string" ? it.shortcode : undefined;
+        const shortcode = typeof it.shortcode === "string" ? it.shortcode : undefined;
         const ref = lookup("mysticalability", shortcode);
         // No shortcode fallback here: an ability with neither an inline name
         // nor an index entry has nothing to show, and a row reading like a

package/sohl/index.mjs

@@ -47,9 +47,4 @@ export * as kbPasses from "./kb-passes.mjs";
 // compilers arrived (#1510).
 export { DEFAULT_ITEM_ART, defaultItemArt } from "./default-item-art.mjs";
 export { AFFILIATION_STANDINGS } from "./affiliation-standings.mjs";
-export {
-    BEING_TYPE,
-    GEAR_TYPE_TO_KEY,
-    deriveBeingInfo,
-    isBeing,
-} from "./being-info.mjs";
+export { BEING_TYPE, GEAR_TYPE_TO_KEY, deriveBeingInfo, isBeing } from "./being-info.mjs";