@heroiclands/package-build 8.0.0 → 9.0.0

package/engine/map-notes.mjs

@@ -55,10 +55,7 @@ import { compendiumUuid, makeId, MAP_TYPES } from "./ids.mjs";
 // The curated region-event vocabulary is shared verbatim with the runtime
 // bridge (`SohlRegionTriggerBehavior`), so an event this build accepts is
 // exactly one the bridge forwards.
-import {
-    CURATED_REGION_EVENTS,
-    EXCLUDED_REGION_EVENTS,
-} from "./region-events.mjs";
+import { CURATED_REGION_EVENTS, EXCLUDED_REGION_EVENTS } from "./region-events.mjs";
 
 /* -------------------------------------------------------------------- */
 /*  Note types and their canvas profiles                                */
@@ -266,10 +263,7 @@ export function assertPixelGeometry(coords, geom) {
  * @throws {Error} When the coordinates read as pixels.
  */
 export function assertGridLocation(at, geom) {
-    const [gx, gy] = [
-        geom.dimensions[0] / geom.pxPerGrid,
-        geom.dimensions[1] / geom.pxPerGrid,
-    ];
+    const [gx, gy] = [geom.dimensions[0] / geom.pxPerGrid, geom.dimensions[1] / geom.pxPerGrid];
     if (at[0] > gx || at[1] > gy) {
         throw new Error(
             `${geom.label}: [${at.join(", ")}] lies outside the map's ` +
@@ -408,9 +402,7 @@ function buildWall(segment, spec, geom, { sceneId, id }) {
  * The shape forms a map note may author. `rect` is the short spelling of
  * `rectangle`, as the design's own examples use.
  */
-const SHAPE_FORMS = Object.freeze(
-    new Set(["rect", "rectangle", "circle", "ellipse", "polygon"]),
-);
+const SHAPE_FORMS = Object.freeze(new Set(["rect", "rectangle", "circle", "ellipse", "polygon"]));
 
 /**
  * Compile one authored shape into a Foundry shape record.
@@ -448,20 +440,14 @@ export function buildShape(spec, geom) {
     }
     const raw = spec[form];
     if (!Array.isArray(raw) || raw.some((n) => !Number.isFinite(n))) {
-        throw new Error(
-            `${geom.label}: ${form} takes a flat list of numbers in pixels`,
-        );
+        throw new Error(`${geom.label}: ${form} takes a flat list of numbers in pixels`);
     }
     assertPixelGeometry(raw, geom);
 
     switch (form) {
         case "rect":
         case "rectangle":
-            expectLength(
-                raw,
-                4,
-                `${geom.label}: rectangle is [x, y, width, height]`,
-            );
+            expectLength(raw, 4, `${geom.label}: rectangle is [x, y, width, height]`);
             return {
                 type: "rectangle",
                 x: raw[0],
@@ -506,8 +492,7 @@ export function buildShape(spec, geom) {
             // which is a line segment and encloses nothing.
             if (raw.length < 6) {
                 throw new Error(
-                    `${geom.label}: a polygon needs at least 3 points; got ` +
-                        `${raw.length / 2}`,
+                    `${geom.label}: a polygon needs at least 3 points; got ` + `${raw.length / 2}`,
                 );
             }
             return { type: "polygon", points: [...raw], hole };
@@ -601,9 +586,7 @@ const BEHAVIOR_SPECS = Object.freeze({
  *
  * @type {ReadonlySet<string>}
  */
-export const REGION_BEHAVIOR_TYPES = Object.freeze(
-    new Set(Object.keys(BEHAVIOR_SPECS)),
-);
+export const REGION_BEHAVIOR_TYPES = Object.freeze(new Set(Object.keys(BEHAVIOR_SPECS)));
 
 /**
  * Behaviour types a map note may **never** carry, and why.
@@ -657,8 +640,7 @@ function buildBehavior(key, spec, ctx) {
     const [type] = types;
 
     const banned = BANNED_REGION_BEHAVIOR_TYPES.get(type);
-    if (banned)
-        throw new Error(`${label}: "${type}" is not permitted — ${banned}`);
+    if (banned) throw new Error(`${label}: "${type}" is not permitted — ${banned}`);
     const behaviorSpec = BEHAVIOR_SPECS[type];
     if (!behaviorSpec) {
         throw new Error(
@@ -680,13 +662,7 @@ function buildBehavior(key, spec, ctx) {
         }
     }
 
-    const system = compileBehaviorSystem(
-        type,
-        authored,
-        behaviorSpec,
-        label,
-        ctx,
-    );
+    const system = compileBehaviorSystem(type, authored, behaviorSpec, label, ctx);
     const id = behaviorDocId(ctx.regionId, key, spec._id);
     const doc = {
         _id: id,
@@ -730,23 +706,17 @@ function compileBehaviorSystem(type, authored, behaviorSpec, label, ctx) {
             const { to, ...rest } = authored;
             return {
                 ...rest,
-                destinations: toList(to).map((addr) =>
-                    ctx.resolveRegionRef(addr, label),
-                ),
+                destinations: toList(to).map((addr) => ctx.resolveRegionRef(addr, label)),
             };
         }
         case "toggleBehavior": {
             const { enable, disable, ...rest } = authored;
             const out = { ...rest, events: [...authored.events] };
             if (enable) {
-                out.enable = toList(enable).map((a) =>
-                    ctx.resolveBehaviorRef(a, label),
-                );
+                out.enable = toList(enable).map((a) => ctx.resolveBehaviorRef(a, label));
             }
             if (disable) {
-                out.disable = toList(disable).map((a) =>
-                    ctx.resolveBehaviorRef(a, label),
-                );
+                out.disable = toList(disable).map((a) => ctx.resolveBehaviorRef(a, label));
             }
             return out;
         }
@@ -765,9 +735,7 @@ function compileBehaviorSystem(type, authored, behaviorSpec, label, ctx) {
         }
         case "applyActiveEffect": {
             return {
-                effects: toList(authored.effects).map((a) =>
-                    ctx.resolveEffectRef(a, label),
-                ),
+                effects: toList(authored.effects).map((a) => ctx.resolveEffectRef(a, label)),
             };
         }
         default:
@@ -821,13 +789,7 @@ const REGION_VISIBILITY = Object.freeze({
 });
 
 /** `CONST.EDGE_RESTRICTION_TYPES`. */
-const RESTRICTION_TYPES = Object.freeze([
-    "light",
-    "darkness",
-    "sight",
-    "sound",
-    "move",
-]);
+const RESTRICTION_TYPES = Object.freeze(["light", "darkness", "sight", "sound", "move"]);
 
 /**
  * Compile one authored region into a Region document with its behaviours.
@@ -925,9 +887,7 @@ export function buildScene(fm, ctx) {
         dimensions.length !== 2 ||
         !dimensions.every((n) => Number.isInteger(n) && n > 0)
     ) {
-        throw new Error(
-            "`dimensions` is [width, height] in whole pixels — the map's own size",
-        );
+        throw new Error("`dimensions` is [width, height] in whole pixels — the map's own size");
     }
     const pxPerGrid = sohl.pxPerGrid;
     if (!Number.isInteger(pxPerGrid) || pxPerGrid <= 0) {
@@ -981,9 +941,7 @@ export function buildScene(fm, ctx) {
 
     if (ctx.journalEntryId) {
         if (!ctx.packageId) {
-            throw new Error(
-                "a map note with a journal needs `packageId` in its compile context",
-            );
+            throw new Error("a map note with a journal needs `packageId` in its compile context");
         }
         // `Scene.journal` is a plain ForeignDocumentField, which
         // `ForeignDocumentField#initialize` unconditionally nulls inside a
@@ -992,12 +950,7 @@ export function buildScene(fm, ctx) {
         // pack needs the flag to find the entry at all.
         scene.journal = ctx.journalEntryId;
         scene.flags[ctx.packageId] = {
-            docUuid: compendiumUuid(
-                ctx.packageId,
-                "doc",
-                ctx.journalEntryId,
-                ctx.journalPack,
-            ),
+            docUuid: compendiumUuid(ctx.packageId, "doc", ctx.journalEntryId, ctx.journalPack),
         };
     }
     return scene;
@@ -1050,9 +1003,7 @@ export function buildWalls(sohl, geom, ctx) {
         const label = `walls.${key}`;
         const segments = toList(spec.segments);
         if (!segments.length) {
-            throw new Error(
-                `${label}: a wall group needs at least one segment`,
-            );
+            throw new Error(`${label}: a wall group needs at least one segment`);
         }
         segments.forEach((segment, i) => {
             const id = makeId("scene-wall", `${ctx.sceneId}:${key}:${i}`);
@@ -1171,8 +1122,7 @@ export function buildSounds(sohl, geom, ctx) {
     return Object.entries(sohl.sounds ?? {}).map(([key, spec]) => {
         const label = `sounds.${key}`;
         const [x, y] = requirePosition(spec.position, { ...geom, label });
-        if (!spec.path)
-            throw new Error(`${label}: an ambient sound needs a path`);
+        if (!spec.path) throw new Error(`${label}: an ambient sound needs a path`);
         const id = spec._id || makeId("scene-sound", `${ctx.sceneId}:${key}`);
         return {
             _id: id,

package/engine/note-package.mjs

@@ -104,10 +104,7 @@ export function searchableFrontmatter(fm, configured) {
  * @returns {void}
  * @throws {Error} When the note declares the field.
  */
-export function assertNoDeclaredPackage(
-    fm,
-    { file, absPath, configured } = {},
-) {
+export function assertNoDeclaredPackage(fm, { file, absPath, configured } = {}) {
     if (!fm || typeof fm !== "object" || !Object.hasOwn(fm, "package")) return;
 
     const target = configured ?? contentPackage();

package/engine/pack-config.mjs

@@ -81,11 +81,7 @@ import { createRequire } from "node:module";
 import YAML from "yaml";
 
 import { defineConfig, DERIVED_SYSTEM_VERSION } from "../content-config.mjs";
-import {
-    formatDiagnostic,
-    positionOfYamlPath,
-    yamlKeyPath,
-} from "./diagnostics.mjs";
+import { formatDiagnostic, positionOfYamlPath, yamlKeyPath } from "./diagnostics.mjs";
 
 /** The stem every consuming repository declares its build under. */
 export const CONFIG_BASENAME = "package-build.config";
@@ -130,9 +126,9 @@ export const CONFIG_FILENAMES = Object.freeze([
 export function findConfigFile(from) {
     let dir = path.resolve(from);
     for (;;) {
-        const found = CONFIG_FILENAMES.map((name) =>
-            path.join(dir, name),
-        ).filter((candidate) => fs.existsSync(candidate));
+        const found = CONFIG_FILENAMES.map((name) => path.join(dir, name)).filter((candidate) =>
+            fs.existsSync(candidate),
+        );
         if (found.length > 1) {
             throw new Error(
                 `package-build: ${dir} holds more than one configuration ` +
@@ -275,11 +271,9 @@ function shippedSystemVersion(rootDir, input) {
         return pkg.version;
     }
 
-    const systemId = /** @type {Record<string, unknown>} */ (input.stats ?? {})
-        .systemId;
-    const declaredSystems = /** @type {Record<string, unknown>} */ (
-        input.relationships ?? {}
-    ).systems;
+    const systemId = /** @type {Record<string, unknown>} */ (input.stats ?? {}).systemId;
+    const declaredSystems = /** @type {Record<string, unknown>} */ (input.relationships ?? {})
+        .systems;
 
     // The `systems:` block declares without requiring (#48), so it is consulted
     // first: a package that has adopted it needs no relationship, and one that
@@ -288,10 +282,9 @@ function shippedSystemVersion(rootDir, input) {
     // otherwise a single declared system is unambiguous. With several and no
     // gate, there is no package-wide answer — each pack carries its own, and
     // {@link statsForPack} is what reads it.
-    const systemsBlock =
-        /** @type {Record<string, {compatibility?: {verified?: string}}>} */ (
-            input.systems ?? {}
-        );
+    const systemsBlock = /** @type {Record<string, {compatibility?: {verified?: string}}>} */ (
+        input.systems ?? {}
+    );
     const systemIds = Object.keys(systemsBlock);
     if (systemIds.length) {
         const chosen =
@@ -300,8 +293,7 @@ function shippedSystemVersion(rootDir, input) {
             : null;
         if (chosen) {
             const verified = systemsBlock[chosen]?.compatibility?.verified;
-            if (typeof verified === "string" && verified.length)
-                return verified;
+            if (typeof verified === "string" && verified.length) return verified;
         }
         // Several declared and none required: the package-wide value is
         // deliberately absent rather than one of them picked arbitrarily.
@@ -323,11 +315,9 @@ function shippedSystemVersion(rootDir, input) {
 
     const systems =
         /** @type {{id?: string, compatibility?: {verified?: string}}[]} */ (
-            /** @type {Record<string, unknown>} */ (input.relationships ?? {})
-                .systems
+            /** @type {Record<string, unknown>} */ (input.relationships ?? {}).systems
         ) ?? [];
-    const relationship =
-        systems.find((entry) => entry?.id === systemId) ?? systems[0];
+    const relationship = systems.find((entry) => entry?.id === systemId) ?? systems[0];
     const verified = relationship?.compatibility?.verified;
 
     if (typeof verified !== "string" || verified.length === 0) {
@@ -413,11 +403,7 @@ export function locateConfigError(err, configPath) {
             err
         );
     if (!(err instanceof Error)) return err;
-    if (
-        failure.located ||
-        typeof failure.field !== "string" ||
-        !failure.field
-    ) {
+    if (failure.located || typeof failure.field !== "string" || !failure.field) {
         return err;
     }
     if (!configPath) return err;
@@ -562,10 +548,7 @@ function loadCodeConfig(configPath) {
         // arrive here. There is no YAML to locate into, but the file is known —
         // `locateConfigError` names it and drops the line.
         locateConfigError(err, configPath);
-        if (
-            /** @type {{ code?: string }} */ (err)?.code ===
-            "ERR_REQUIRE_ASYNC_MODULE"
-        ) {
+        if (/** @type {{ code?: string }} */ (err)?.code === "ERR_REQUIRE_ASYNC_MODULE") {
             throw new Error(
                 `package-build: ${configPath} (or something it imports) uses ` +
                     `top-level await, which the configuration cannot: it is ` +
@@ -603,8 +586,7 @@ export function loadPackConfig() {
     if (loaded) return loaded;
 
     const explicit = process.env.PACKAGE_BUILD_CONFIG;
-    const configPath =
-        explicit ? path.resolve(explicit) : findConfigFile(import.meta.dirname);
+    const configPath = explicit ? path.resolve(explicit) : findConfigFile(import.meta.dirname);
 
     if (!configPath || !fs.existsSync(configPath)) {
         throw new Error(
@@ -621,10 +603,7 @@ export function loadPackConfig() {
     loaded =
         configPath.endsWith(".mjs") ?
             loadCodeConfig(configPath)
-        :   configFromData(
-                YAML.parse(fs.readFileSync(configPath, "utf8")),
-                configPath,
-            );
+        :   configFromData(YAML.parse(fs.readFileSync(configPath, "utf8")), configPath);
     loadedFrom = configPath;
     return loaded;
 }

package/engine/pack-router.mjs

@@ -117,8 +117,7 @@ export function createPackRouter(packs) {
     }
 
     /** @param {object} fm */
-    const noteLabel = (fm) =>
-        fm?.name?.full ?? fm?.shortcode ?? fm?.id ?? "a note";
+    const noteLabel = (fm) => fm?.name?.full ?? fm?.shortcode ?? fm?.id ?? "a note";
 
     /**
      * The pack one pass should write this note's document to.

package/engine/prose-config.mjs

@@ -46,7 +46,25 @@
  * @type {Readonly<object>}
  */
 export const PRETTIER_BASE = Object.freeze({
-    printWidth: 80,
+    // 100, not the conventional 80. The usual argument for 80 is reading
+    // measure, and it does not apply here: `proseWrap` is left at Prettier's
+    // default of `preserve`, so authored prose is never reflowed at all — the
+    // notes in these trees run to a p90 of 378 characters a line and are
+    // untouched by this number. What it actually governs is TypeScript and the
+    // YAML of a note's frontmatter, and both were measurably cramped at 80.
+    //
+    // Measured before changing it, across a third of the SoHL source: at 80,
+    // Prettier *fails* to honour the limit on 1,399 lines — long string
+    // literals, `@src/…` specifiers, generic signatures — so those lines are
+    // over-width anyway and their surroundings were broken up for nothing. At
+    // 100 that falls to 75, and the file is 4.9% shorter. Past 100 the returns
+    // flatten (120 buys another 2.6%).
+    //
+    // The same knee appears in content: an item entry written in flow style —
+    // `{ shortcode: X, type: skill, name: …, system: { … } }` — typically lands
+    // in the low 90s, so 90.8% of 318,030 entries fit on one line at 80 and
+    // 95.3% at 100, with almost nothing gained in between.
+    printWidth: 100,
     tabWidth: 4,
     useTabs: false,
     semi: true,
@@ -113,9 +131,7 @@ export const PRETTIER_CONFIG = Object.freeze({
  *   `overrides`: passing that inline is what silently did nothing (#76).
  */
 export function sharedPrettierOptionsFor(file) {
-    return /\.md$/i.test(file) ?
-            { ...PRETTIER_BASE, ...PRETTIER_MARKDOWN }
-        :   { ...PRETTIER_BASE };
+    return /\.md$/i.test(file) ? { ...PRETTIER_BASE, ...PRETTIER_MARKDOWN } : { ...PRETTIER_BASE };
 }
 
 /**

package/engine/prose-lint.mjs

@@ -116,18 +116,13 @@ export async function checkFormatting(root, opts = {}) {
     const { paths, write = false } = opts;
     const prettier = opts.prettier ?? (await import("prettier"));
     const base = path.resolve(root);
-    const ignorePath = IGNORE_FILES.map((name) => path.join(base, name)).filter(
-        (file) => fs.existsSync(file),
+    const ignorePath = IGNORE_FILES.map((name) => path.join(base, name)).filter((file) =>
+        fs.existsSync(file),
     );
 
-    const roots =
-        paths?.length ?
-            paths.map((entry) => path.resolve(base, entry))
-        :   [base];
+    const roots = paths?.length ? paths.map((entry) => path.resolve(base, entry)) : [base];
     const candidates = roots.flatMap((entry) =>
-        fs.existsSync(entry) && fs.statSync(entry).isDirectory() ?
-            walkFiles(entry)
-        :   [entry],
+        fs.existsSync(entry) && fs.statSync(entry).isDirectory() ? walkFiles(entry) : [entry],
     );
 
     const findings = [];
@@ -175,8 +170,7 @@ export async function checkFormatting(root, opts = {}) {
                     // No line or column: Prettier's answer is about the whole
                     // file, and #17's rule is to drop a field rather than
                     // invent one.
-                    message:
-                        "is not formatted; run `content-build format --write` to fix it",
+                    message: "is not formatted; run `content-build format --write` to fix it",
                 });
             }
         } catch (err) {
@@ -189,9 +183,7 @@ export async function checkFormatting(root, opts = {}) {
             const loc = err?.loc?.start ?? err?.loc;
             findings.push({
                 file,
-                ...(Number.isFinite(loc?.line) ?
-                    { line: loc.line, column: loc.column }
-                :   {}),
+                ...(Number.isFinite(loc?.line) ? { line: loc.line, column: loc.column } : {}),
                 severity: "error",
                 message: `cannot be parsed: ${String(err?.message ?? err).split("\n")[0]}`,
             });

package/engine/region-events.mjs

@@ -54,9 +54,7 @@ export const REGION_EVENT_TO_TRIGGER = Object.freeze({
  *
  * @type {readonly string[]}
  */
-export const CURATED_REGION_EVENTS = Object.freeze(
-    Object.keys(REGION_EVENT_TO_TRIGGER),
-);
+export const CURATED_REGION_EVENTS = Object.freeze(Object.keys(REGION_EVENT_TO_TRIGGER));
 
 /**
  * Region events SoHL deliberately does **not** forward: the continuous

package/engine/scene-levels.mjs

@@ -87,9 +87,7 @@ const LEVEL_SPLITTING_CLI = "3.0.3";
  */
 export function compendiumCliVersion() {
     try {
-        return createRequire(import.meta.url)(
-            "@foundryvtt/foundryvtt-cli/package.json",
-        ).version;
+        return createRequire(import.meta.url)("@foundryvtt/foundryvtt-cli/package.json").version;
     } catch {
         return undefined;
     }
@@ -128,8 +126,7 @@ function levelIdOf(entry) {
  * @returns {string} A phrase naming the entry, never `[object Object]`.
  */
 function describeEntry(entry, index) {
-    if (isInlineLevel(entry))
-        return `\`levels[${index}]\` is ${describeShape(entry)}`;
+    if (isInlineLevel(entry)) return `\`levels[${index}]\` is ${describeShape(entry)}`;
     return `\`levels[${index}]\` is ${JSON.stringify(entry) ?? String(entry)}`;
 }
 
@@ -234,15 +231,11 @@ function describeRemedy(cliVersion) {
  * @returns {string} One report covering every affected scene.
  */
 function describeWholesaleLoss(declaring, cliVersion) {
-    const inline = declaring.some(([, scene]) =>
-        declaredLevels(scene).some(isInlineLevel),
-    );
+    const inline = declaring.some(([, scene]) => declaredLevels(scene).some(isInlineLevel));
     const list = declaring
         .map(([sceneId, scene]) => {
             const entries = declaredLevels(scene)
-                .map((entry) =>
-                    isInlineLevel(entry) ? describeShape(entry) : `"${entry}"`,
-                )
+                .map((entry) => (isInlineLevel(entry) ? describeShape(entry) : `"${entry}"`))
                 .join(", ");
             return `${nameScene(sceneId, scene)} → ${entries}`;
         })
@@ -329,9 +322,7 @@ export function checkSceneLevels(records, { cliVersion } = {}) {
     // No scene in the pack has a Level record: one fact about the compile,
     // which saying per scene would bury. Scenes declaring nothing are not
     // covered by it, so they are still judged individually below.
-    const declaring = scenes.filter(
-        ([, scene]) => declaredLevels(scene).length,
-    );
+    const declaring = scenes.filter(([, scene]) => declaredLevels(scene).length);
     const wholesale = levelKeys.size === 0 && declaring.length > 0;
     if (wholesale) problems.push(describeWholesaleLoss(declaring, cliVersion));
 
@@ -357,9 +348,7 @@ export function checkSceneLevels(records, { cliVersion } = {}) {
                         `${LEVEL_SPLITTING_CLI} writes.`,
                 );
             } else if (!id) {
-                broken.push(
-                    `${where}: ${describeEntry(entry, index)}, not a Level id.`,
-                );
+                broken.push(`${where}: ${describeEntry(entry, index)}, not a Level id.`);
             } else if (!levelKeys.has(`${sceneId}.${id}`)) {
                 broken.push(
                     `${where} lists level "${id}", but no record exists at ` +
@@ -372,16 +361,13 @@ export function checkSceneLevels(records, { cliVersion } = {}) {
         // A broken entry is already reported above; only the declaration
         // itself is judged here, so nothing is reported twice.
         if (broken.length) problems.push(...broken);
-        else
-            problems.push(...checkDeclaredLevels(scene ?? {}, declared, where));
+        else problems.push(...checkDeclaredLevels(scene ?? {}, declared, where));
     }
 
     for (const adventure of adventures) {
         const inline = Array.isArray(adventure?.scenes) ? adventure.scenes : [];
         for (const scene of inline) {
-            const levelIds = declaredLevels(scene).map(
-                (level) => levelIdOf(level) ?? level,
-            );
+            const levelIds = declaredLevels(scene).map((level) => levelIdOf(level) ?? level);
             const where =
                 `Adventure "${adventure?.name ?? adventure?._id}" scene ` +
                 `"${scene?.name ?? scene?._id}"`;

package/engine/scenes.mjs

@@ -51,25 +51,14 @@ import fs from "fs";
 import path from "path";
 import log from "loglevel";
 
-import {
-    walkMarkdownTree,
-    sohlField,
-    resolveName,
-    slugify,
-    defaultStats,
-} from "./helpers.mjs";
+import { walkMarkdownTree, sohlField, resolveName, slugify, defaultStats } from "./helpers.mjs";
 import { BasePackCompiler } from "./base-compiler.mjs";
 import { buildJournalEntry, splitPages, journalPageId } from "./journals.mjs";
 import { compendiumUuid, makeId, packForType } from "./ids.mjs";
 import { packRouter } from "./pack-router.mjs";
 import { foundryPackageId } from "./content-package.mjs";
 import { itemDocEntryId } from "./item-docs.mjs";
-import {
-    behaviorDocId,
-    buildScene,
-    isMapType,
-    regionDocId,
-} from "./map-notes.mjs";
+import { behaviorDocId, buildScene, isMapType, regionDocId } from "./map-notes.mjs";
 
 /**
  * Every SoHL action name this build knows about, for the `action:` warning on a
@@ -158,9 +147,7 @@ export class Scenes extends BasePackCompiler {
     }) {
         super({ contentBase, dest, folderResolver });
         if (!companionDests.adventures) {
-            throw new Error(
-                "Scenes compiler requires an `adventures` companion destination",
-            );
+            throw new Error("Scenes compiler requires an `adventures` companion destination");
         }
         Object.defineProperty(this, "adventureDir", {
             value: companionDests.adventures,
@@ -188,30 +175,21 @@ export class Scenes extends BasePackCompiler {
     #collect() {
         const maps = [];
         const effectsByAddress = new Map();
-        for (const { frontmatter: fm, body, absPath } of walkMarkdownTree(
-            this.contentBase,
-        )) {
+        for (const { frontmatter: fm, body, absPath } of walkMarkdownTree(this.contentBase)) {
             // No retired-field test: this pass's own walk — the shared compile
             // loop — is where a note still declaring `package:` (#56) or
             // `draft:` (#69) is reported, once. Repeating either check here
             // would double the diagnostic or throw past it. A refused note is
             // indexed and then never compiled, so it reaches no document.
             if (!fm || !fm.id) continue;
-            if (
-                fm.shortcode &&
-                Array.isArray(fm.effects) &&
-                fm.effects.length
-            ) {
+            if (fm.shortcode && Array.isArray(fm.effects) && fm.effects.length) {
                 effectsByAddress.set(`${fm.type}-${fm.shortcode}`, {
                     id: fm.id,
                     type: fm.type,
                     // Where the owning item landed, so a region behaviour's
                     // effect reference addresses the right pack when a
                     // repository ships several of one type (#1566).
-                    pack: packRouter().resolveOrNull(
-                        fm,
-                        packForType(fm.type).docType,
-                    ),
+                    pack: packRouter().resolveOrNull(fm, packForType(fm.type).docType),
                     effects: fm.effects,
                 });
             }
@@ -239,17 +217,13 @@ export class Scenes extends BasePackCompiler {
                 throw new Error(`Map note missing shortcode: ${absPath}`);
             }
             if (index.has(fm.shortcode)) {
-                throw new Error(
-                    `Two map notes share the shortcode "${fm.shortcode}"`,
-                );
+                throw new Error(`Two map notes share the shortcode "${fm.shortcode}"`);
             }
             const regions = new Map();
             for (const [key, spec] of Object.entries(fm.sohl?.regions ?? {})) {
                 const id = regionDocId(fm.id, key, spec?._id);
                 const behaviors = new Map();
-                for (const [bKey, bSpec] of Object.entries(
-                    spec?.behaviors ?? {},
-                )) {
+                for (const [bKey, bSpec] of Object.entries(spec?.behaviors ?? {})) {
                     behaviors.set(bKey, behaviorDocId(id, bKey, bSpec?._id));
                 }
                 regions.set(key, { id, behaviors });
@@ -283,9 +257,7 @@ export class Scenes extends BasePackCompiler {
             const mapKey = addr.map ?? selfShortcode;
             const target = index.get(mapKey);
             if (!target) {
-                throw new Error(
-                    `${label}: no map note has the shortcode "${mapKey}"`,
-                );
+                throw new Error(`${label}: no map note has the shortcode "${mapKey}"`);
             }
             const region = target.regions.get(addr.region);
             if (!region) {
@@ -305,9 +277,7 @@ export class Scenes extends BasePackCompiler {
             resolveBehaviorRef: (addr, label) => {
                 const { target, region } = lookupRegion(addr, label);
                 if (!addr.behavior) {
-                    throw new Error(
-                        `${label}: a behaviour reference is {map, region, behavior}`,
-                    );
+                    throw new Error(`${label}: a behaviour reference is {map, region, behavior}`);
                 }
                 const behaviorId = region.behaviors.get(addr.behavior);
                 if (!behaviorId) {
@@ -317,8 +287,7 @@ export class Scenes extends BasePackCompiler {
                     );
                 }
                 return (
-                    `Scene.${target.sceneId}.Region.${region.id}` +
-                    `.RegionBehavior.${behaviorId}`
+                    `Scene.${target.sceneId}.Region.${region.id}` + `.RegionBehavior.${behaviorId}`
                 );
             },
             resolveEffectRef: (addr, label) => {
@@ -420,8 +389,7 @@ export class Scenes extends BasePackCompiler {
             // default JournalEntry pack, not in whichever Scene pack the map
             // itself was routed to (#1566).
             journalPack: packRouter().defaultOf("JournalEntry"),
-            pageIds:
-                hasBody ? this.#pageIds(markdown, entryId, name) : new Map(),
+            pageIds: hasBody ? this.#pageIds(markdown, entryId, name) : new Map(),
             knownActions: this.knownActions,
             warnings,
             ...this.#resolvers(this.index, this.effectsByAddress, fm.shortcode),
@@ -489,9 +457,7 @@ export class Scenes extends BasePackCompiler {
 
     /** @inheritdoc */
     reportCompiled(stats) {
-        log.info(
-            `Compiled ${stats.compiled} scene(s) and ${this.adventureCount} adventure(s)`,
-        );
+        log.info(`Compiled ${stats.compiled} scene(s) and ${this.adventureCount} adventure(s)`);
     }
 
     /**