@heroiclands/package-build 23.1.1 → 23.2.1

package/engine/note-vocabulary.mjs

@@ -44,15 +44,12 @@
  * transmission — and is true of it whichever system is reading. What each
  * system makes of that value is declared elsewhere, in that system's own half.
  *
- * **The type names here are the specification's**, which renamed `armor`,
- * `projectile` and `concoction` off the `…gear` spellings that named a SoHL
- * document subtype rather than the thing the note is about. `weapon` is the one
+ * **The type names here are the specification's**: `armor`, `projectile`
+ * and `concoction` name the thing the note is about, not a SoHL document
+ * subtype in a `…gear` spelling. `weapon` is the one
  * the specification and this registry still spell differently: both systems
  * call that document a `weapongear`, so the name says nothing system-specific
- * and the table has no row for it. A note left on a renamed spelling still
- * reaches its entry — every type-keyed lookup normalises through
- * `RENAMED_TYPES` — and is reported rather than refused until the content trees
- * have swept.
+ * and the table has no row for it.
  *
  * **A type name and a subType value are held to the address charset**, so
  * both match `ADDRESS_SEGMENT_PATTERN` — the charset `engine/address-charset.mjs`
@@ -64,10 +61,8 @@
  * would be read back as two segments and resolve to nothing, reporting nothing
  * about why.
  *
- * A subType reaches no address of its own. It did when this rule was written —
- * a `doc`'s was its section, a path segment — and sections are retired from
- * the note format one release later. It keeps the rule regardless, and the
- * reason is not inertia: a subType is a vocabulary term the whole toolchain
+ * A subType reaches no address of its own. It keeps the charset rule regardless,
+ * and the reason is not inertia: a subType is a vocabulary term the whole toolchain
  * keys on, it is one closed set away from being an address again, and a charset
  * that held for a type, a shortcode and a package but not for a subType would
  * be a rule nobody could state in one sentence. The registry below is checked
@@ -84,10 +79,7 @@ import { ADDRESS_SEGMENT_PATTERN, isAddressSegment } from "./address-charset.mjs
 // The system registry, so the top-level block keys below are the systems this
 // toolchain recognises rather than a second list of them.
 import { SYSTEM_IDS } from "./systems.mjs";
-// The retirement window for a renamed type, read rather than restated: a
-// vocabulary that answered only to the current spelling would report every key
-// of an unswept note as unknown.
-import { currentType } from "./ids.mjs";
+import { packForType } from "./ids.mjs";
 // What a place is next to and reachable from — the two relation lists and
 // the checks that hold them to their closed sets and to each other.
 import { checkBorders, checkRoutes } from "./place-relations.mjs";
@@ -118,7 +110,7 @@ import { checkNoteEvents } from "./note-events.mjs";
 // list the compiled Item is held to, so the lint and the compile cannot differ.
 import { AFFILIATION_STANDINGS } from "../sohl/affiliation-standings.mjs";
 import { EVENT_ENTRY } from "./note-event-terms.mjs";
-import { checkCultureChoice } from "./culture-choice.mjs";
+import { CULTURE_FIELD, checkCultureSubType } from "./culture-choice.mjs";
 import { LITERATURE_FIELDS, checkLiteratureNote } from "./literature-notes.mjs";
 import { SOCIAL_TIES, SOCIAL_TIE_TARGET_TYPES } from "./social-tie-terms.mjs";
 import { parseNoteDate } from "./note-dates.mjs";
@@ -148,15 +140,12 @@ import { positionOfFrontmatterPath } from "./diagnostics.mjs";
  * @typedef {object} DataFieldSpec
  * @property {string} name - The key under `data:`, dotted for a nested one
  *   (`charges.value`).
- * @property {"string"|"number"|"boolean"|"list"|"map"|"list-or-map"|"scalar-or-map"|"address"|"shortcode"} [kind] -
+ * @property {"string"|"number"|"boolean"|"list"|"map"|"scalar-or-map"|"address"|"shortcode"} [kind] -
  *   The value's shape, for the lint. Absent means no claim is made about the
  *   value — which is the honest answer wherever the specification's stated
  *   shape and the shape notes are authored in today disagree.
  * @property {"address"|"shortcode"} [entryKind] - Type of each list or pack-map value.
- * @property {"address"|"shortcode"} [keyKind] - Type of each map key. On a
- *   `list-or-map` field it describes the map form alone, and `entryKind` the
- *   list form alone: reading both of one value would check a map's entries as
- *   if they were its keys.
+ * @property {"address"|"shortcode"} [keyKind] - Type of each map key.
  * @property {boolean} [standings] - The map's entries are standings held in the
  *   body each is keyed by, so a row names the two together — see
  *   {@link module:engine/standings}.
@@ -164,6 +153,9 @@ import { positionOfFrontmatterPath } from "./diagnostics.mjs";
  *   so each takes a row labelled and anchored by the post's own name.
  * @property {"subType"} [keySelector] - An alternative `subType:<skill-subtype>` key.
  * @property {readonly string[]} [accepts] - Allowed Address types, separate from `ref`.
+ * @property {string} [declines] - The literal value that declines the art this
+ *   Address field names. It is not an Address, is never resolved, and is not
+ *   reported as unresolved.
  * @property {readonly ("prose"|"event")[]} [anchors] - The anchor kinds an
  *   Address here may name with `#<anchor>`. Absent, an anchor is refused.
  * @property {boolean} [single] - The Address names exactly one event: an
@@ -179,6 +171,10 @@ import { positionOfFrontmatterPath } from "./diagnostics.mjs";
  *   one — `icon` for `icon` and `tokenIcon`, `image` for `banner` — so `icon: anvil` names `icon-anvil` while a value carrying the
  *   separator states its own address. Distinct from a `FieldSpec`'s `code`
  *   ({@link module:engine/field-spec}), which names a **Shortcode** instead.
+ * @property {string} [sceneProperty] - On a map, the exported Scene property an
+ *   Address field's resolved path is written into, as a `data.fixup` path. The
+ *   Scene compile applies the field as one more fixup — see
+ *   {@link module:engine/exported-scene}.
  * @property {"pack"} [keys] - For a `scalar-or-map` field, what its keys name.
  *   `"pack"` means each is a pack this package declares, so a key naming none
  *   is a finding of its own: it addresses a hierarchy nothing will ever read.
@@ -196,6 +192,8 @@ import { positionOfFrontmatterPath } from "./diagnostics.mjs";
  *   entries are not Addresses (`entryKind` says that).
  * @property {object} [values] - What the value under each key of a keyed map
  *   is, where the keys are data rather than declared names.
+ * @property {readonly string[]} [allowed] - The closed set a present string
+ *   value is one of; any other word is a finding at the value.
  * @property {string} describe - One line, for the author-facing reference.
  */
 
@@ -243,6 +241,18 @@ const NUM = Object.freeze({ shape: "number", kind: "number" });
 /** A string, including the enumerated-value fields the format spells as one. */
 const TEXT = Object.freeze({ shape: "string", kind: "string" });
 
+/** The words a being's `gender` takes. */
+const BEING_GENDERS = Object.freeze(["male", "female", "nonbinary", "none", "other"]);
+
+/** The words a being's `frame` takes, lightest to heaviest. */
+const BEING_FRAMES = Object.freeze(["scant", "light", "medium", "heavy", "massive"]);
+
+/** Words as code spans, joined by commas and a final "or". */
+function wordList(words) {
+    const spans = words.map((word) => `\`${word}\``);
+    return `${spans.slice(0, -1).join(", ")} or ${spans.at(-1)}`;
+}
+
 /** A list. */
 const LIST = Object.freeze({ shape: "list", kind: "list" });
 
@@ -258,8 +268,6 @@ const TEXT_LIST = Object.freeze({
  *
  * The two are the same fact at different lengths rather than two different
  * facts, so a single value means a list of one and a consumer reads one shape.
- * That is what separates this from `list-or-map`, whose halves say different
- * things.
  */
 const TEXT_OR_LIST = Object.freeze({
     shape: "string or list",
@@ -278,17 +286,11 @@ const LINKS = Object.freeze({ shape: "list of Addresses", kind: "list", entryKin
  *
  * A map keyed by the body's Address, whose entry is that membership's `rank`
  * and `office` — the pair a flat list of bodies cannot state, because it has
- * nowhere to say which body a standing is held in.
- *
- * **`list-or-map` is the sweep's shape**, and it says which half each
- * declaration describes: `entryKind` the list's entries, `keyKind` the map's
- * keys. A tree still writing the list form keeps the check it had, and the map
- * form earns the two the body can answer — see {@link module:engine/standings}.
+ * nowhere to say which body a standing is held in. A list is an error.
  */
 const STANDINGS = Object.freeze({
-    shape: "a standing map keyed by Address, or a list of Addresses",
-    kind: "list-or-map",
-    entryKind: "address",
+    shape: "a standing map keyed by Address",
+    kind: "map",
     keyKind: "address",
     values: Object.freeze({
         kind: "map",
@@ -484,13 +486,10 @@ export const NOTE_TOP_LEVEL_KEY_SET = Object.freeze(new Set(NOTE_TOP_LEVEL_KEYS)
  * row in twenty-five tables would be twenty-five chances for one of them to
  * disagree with the rest.
  *
- * Both are art slots, and they are legal everywhere for different reasons.
- * `icon` is the document's profile art and most types compile into a document
- * that carries one; where a type's passes emit none, the frontmatter lint says
- * so as a warning rather than the vocabulary refusing the key, because the
- * value may still be read by a page template. `banner` reaches no compiled
- * document at all — it is the page's hero image — and a page is what every note
- * publishes.
+ * `banner` is an art slot legal everywhere: it reaches no compiled document, it
+ * is the page's hero image, and a page is what every note publishes. `icon` is
+ * not shared; it is declared by {@link ICON_FIELD} for the types whose
+ * document carries art.
  *
  * @type {readonly DataFieldSpec[]}
  */
@@ -533,24 +532,54 @@ export const SHARED_DATA_FIELDS = Object.freeze([
         ]),
         describe: "HârnWorld source details shared by every system — `realm` and `ritual`.",
     }),
-    Object.freeze({
-        name: "icon",
-        ...LINK,
-        ref: "icon",
-        accepts: ART_SLOTS.find((slot) => slot.key === "icon").accepts,
-        describe: "The document's profile art — an `icon` address, resolved into `img`.",
-    }),
     Object.freeze({
         name: "banner",
         ...LINK,
         ref: "image",
         accepts: ART_SLOTS.find((slot) => slot.key === "banner").accepts,
+        declines: ART_SLOTS.find((slot) => slot.key === "banner").declines,
         describe:
-            "The page's hero image — an `image` address, cut to 1792×768. " +
-            "Reaches no compiled document.",
+            "The page's hero image — an `image` address, cut to 1792×768, or `none` " +
+            "to decline a hero image. Reaches no compiled document.",
     }),
 ]);
 
+/**
+ * The profile-art field, declared for the types whose document carries art.
+ *
+ * @type {DataFieldSpec}
+ */
+const ICON_FIELD = Object.freeze({
+    name: "icon",
+    ...LINK,
+    ref: "icon",
+    accepts: ART_SLOTS.find((slot) => slot.key === "icon").accepts,
+    describe: "The document's profile art — an `icon` address, resolved into `img`.",
+});
+
+/**
+ * The document types whose builder emits `icon` art: the Actor, Item and Macro
+ * passes and the Adventure (bundle) pass. A Scene and a JournalEntry carry
+ * none. Every pass declares this through its `emitsArt`, and a test holds the
+ * two statements together.
+ *
+ * @type {ReadonlySet<string>}
+ */
+const ICON_DOCUMENT_TYPES = new Set(["Actor", "Item", "Macro", "Adventure"]);
+
+/**
+ * Whether a note type compiles into a document carrying `icon` art.
+ *
+ * A folder and a homepage route like any other type but compile into no art.
+ *
+ * @param {string} type - The current content type.
+ * @returns {boolean} Whether `data.icon` is declared for the type.
+ */
+function emitsIcon(type) {
+    if (type === "folder" || type === "homepage") return false;
+    return ICON_DOCUMENT_TYPES.has(packForType(type).docType);
+}
+
 /**
  * An Address naming one event: `place-ironfells#sack`, or a note holding
  * exactly one event, with a bare shortcode read as a `lore` note.
@@ -686,9 +715,7 @@ function checkPlacePurpose(note) {
  *
  * It is a **presentation** fact and nothing more. A draft note compiles,
  * validates, publishes and resolves like any other; only a link *into* it
- * renders marked. What it emphatically is not is the retired `draft:` field,
- * whose entire effect was to move a note from published to unresolvable — see
- * {@link draftRetiredMessage}.
+ * renders marked.
  */
 export const DRAFT_TAG = "draft";
 
@@ -960,13 +987,6 @@ export const NOTE_VOCABULARY = Object.freeze({
             TEMPLATE_PRIORITY,
             { name: "archetypes", ...TEXT_LIST, describe: "Archetypal behaviours the being fits." },
             { name: "occupation", ...TEXT, describe: "What the being does for a living." },
-            {
-                name: "stations",
-                ...LINKS,
-                ref: "lore",
-                accepts: ["lore"],
-                describe: "Stations the being holds.",
-            },
             {
                 name: "lore",
                 ...LINKS,
@@ -977,11 +997,7 @@ export const NOTE_VOCABULARY = Object.freeze({
                     "subject to, the traditions it was raised in.",
             },
             {
-                name: "culture",
-                ...LINK,
-                ref: "lore",
-                accepts: ["lore"],
-                check: checkCultureChoice,
+                ...CULTURE_FIELD,
                 describe: "The being's primary culture, as a culture lore note.",
             },
             {
@@ -1016,8 +1032,9 @@ export const NOTE_VOCABULARY = Object.freeze({
             {
                 name: "gender",
                 ...TEXT,
+                allowed: BEING_GENDERS,
                 describe:
-                    "One of `male`, `female`, `nonbinary`, `none` or `other`. " +
+                    `One of ${wordList(BEING_GENDERS)}. ` +
                     "`none` says the being has no gender; an absent field says its " +
                     "gender is unrecorded.",
             },
@@ -1042,7 +1059,7 @@ export const NOTE_VOCABULARY = Object.freeze({
                 ref: "lore",
                 accepts: ["lore"],
                 check: checkCalendarChoice,
-                describe: "Calendar used to display this being's dates.",
+                describe: "Calendar that displays this being's dates.",
             },
             {
                 name: "died",
@@ -1088,8 +1105,8 @@ export const NOTE_VOCABULARY = Object.freeze({
             {
                 name: "frame",
                 ...TEXT,
-                describe:
-                    "Relative frame — one of `scant`, `light`, `medium`, `heavy` or `massive`.",
+                allowed: BEING_FRAMES,
+                describe: `Relative frame — one of ${wordList(BEING_FRAMES)}.`,
             },
             { name: "appearance.eye_color", ...TEXT, describe: "Eye colour." },
             { name: "appearance.hair_color", ...TEXT, describe: "Hair colour." },
@@ -1230,6 +1247,10 @@ export const NOTE_VOCABULARY = Object.freeze({
                 accepts: ["affiliation"],
                 describe: "Affiliations it is subordinate to.",
             },
+            {
+                ...CULTURE_FIELD,
+                describe: "The people this affiliation belongs to, as a culture lore note.",
+            },
             {
                 name: "relations",
                 kind: "map",
@@ -1525,8 +1546,20 @@ export const NOTE_VOCABULARY = Object.freeze({
             "concept",
             "settingguide",
         ]),
-        check: checkCitedPopulations,
-        data: Object.freeze([]),
+        // A setting guide introduces one culture and names it; no other genre
+        // states one.
+        check: (note, context) => [
+            ...checkCitedPopulations(note, context),
+            ...checkCultureSubType(note, context),
+        ],
+        data: Object.freeze([
+            {
+                ...CULTURE_FIELD,
+                describe:
+                    "The culture a setting guide introduces, as a culture lore note. " +
+                    "Required on `settingguide`; no other subType states it.",
+            },
+        ]),
     }),
 
     macro: Object.freeze({ stubbable: true, data: Object.freeze([]) }),
@@ -1607,15 +1640,28 @@ export const NOTE_VOCABULARY = Object.freeze({
         ]),
         // A lore note is prose, and what it *is* about is its subType — with
         // two exceptions. A calendar is a division of the year, and a division
-        // is data; a work of literature states whose it is, in what tongue and
-        // about what. The checks scope each family to the subType that means
-        // it, because `DataFieldSpec` declares the keys a type accepts and not
-        // the subType that may write them.
+        // is data; a work of literature states in what tongue it is and what it
+        // concerns. The checks scope each family to the subType that means it,
+        // because `DataFieldSpec` declares the keys a type accepts and not the
+        // subType that may write them. Any lore note may name the people it
+        // belongs to; a culture note names only itself.
         check: (note, context) => [
             ...checkCalendarNote(note, context),
             ...checkLiteratureNote(note),
+            ...checkCultureSubType(note, context),
         ],
-        data: Object.freeze([...CALENDAR_FIELDS, ...LITERATURE_FIELDS, EVENTS_FIELD]),
+        data: Object.freeze([
+            ...CALENDAR_FIELDS,
+            {
+                ...CULTURE_FIELD,
+                describe:
+                    "The people this lore belongs to — for a work of literature, the people " +
+                    "whose work it is — as a culture lore note. A culture note is its own " +
+                    "culture, and states the field only as itself.",
+            },
+            ...LITERATURE_FIELDS,
+            EVENTS_FIELD,
+        ]),
     }),
 
     place: Object.freeze({
@@ -1638,7 +1684,7 @@ export const NOTE_VOCABULARY = Object.freeze({
                 ref: "lore",
                 accepts: ["lore"],
                 check: checkCalendarChoice,
-                describe: "Calendar used to display this place's dates.",
+                describe: "Calendar that displays this place's dates.",
             },
             {
                 name: "demonym",
@@ -1668,6 +1714,10 @@ export const NOTE_VOCABULARY = Object.freeze({
                 accepts: ["place"],
                 describe: "Enclosing places this one sits within.",
             },
+            {
+                ...CULTURE_FIELD,
+                describe: "The people this place belongs to, as a culture lore note.",
+            },
             {
                 name: "population",
                 ...NUM,
@@ -1836,6 +1886,18 @@ export const NOTE_VOCABULARY = Object.freeze({
                 }),
                 describe: "Asset address replacements in an exported Scene.",
             },
+            {
+                name: "thumbnail",
+                ...LINK,
+                ref: "image",
+                accepts: Object.freeze(["image"]),
+                // The Scene property the resolved path is written into, as a
+                // fixup path: the compile applies it as one more `data.fixup`.
+                sceneProperty: ".thumb",
+                describe:
+                    "The map's thumbnail — an `image` address, resolved into the Scene's " +
+                    "`thumb` the way a `data.fixup` entry is. Background art is untouched.",
+            },
             {
                 name: "place",
                 ...LINK,
@@ -1853,11 +1915,8 @@ export const NOTE_VOCABULARY = Object.freeze({
  * What a note carrying a subType outside the address charset is told.
  *
  * **Why the charset holds for a subType, which reaches no address.** The rule
- * said
- * "the hyphen separates the segments of an address", and that was true of a
- * subType when it shipped: `sectionOf` returned a `doc`'s subType, so the value
- * was a URL path segment. Sections are retired and it is not one. The rule
- * stays, on its own footing: a subType is a vocabulary term the whole toolchain
+ * says "the hyphen separates the segments of an address", and a subType is not
+ * one. The rule stands on its own footing: a subType is a vocabulary term the whole toolchain
  * keys on, and it is one closed set away from being an address segment again —
  * so the reason to spell it in the address charset is that a charset holding
  * for a type, a shortcode and a `contentPackage` but not for a subType is a
@@ -1906,7 +1965,7 @@ export function typeCharsetMessage(type) {
  *
  * The message states the reason **per key**, as {@link typeCharsetMessage} and
  * {@link subTypeCharsetMessage} do: a type is an address segment, and a subType
- * is not one, since sections are retired, so a single claim covering both
+ * is not one, so a single claim covering both
  * would be half wrong.
  *
  * @param {Readonly<Record<string, TypeVocabulary>>} vocabulary - The registry.
@@ -1953,11 +2012,16 @@ assertVocabularyCharset(NOTE_VOCABULARY);
  *   one, and is why the lint makes no claim rather than refusing every key.
  */
 export function dataFields(type, vocabulary = NOTE_VOCABULARY) {
-    const entry = vocabulary?.[currentType(type)];
+    const entry = vocabulary?.[type];
     if (!entry) return undefined;
     // The shared keys first, so a type's own declarations keep their authored
     // order behind them and a reader meets the art before the mechanics.
-    return Object.freeze([...SHARED_DATA_FIELDS, ...(entry.data ?? [])]);
+    const key = type;
+    return Object.freeze([
+        ...SHARED_DATA_FIELDS,
+        ...(emitsIcon(key) ? [ICON_FIELD] : []),
+        ...(entry.data ?? []),
+    ]);
 }
 
 /**
@@ -1971,7 +2035,7 @@ export function dataFields(type, vocabulary = NOTE_VOCABULARY) {
  *   it has no `subType` at all — see {@link TypeVocabulary}.
  */
 export function subTypes(type, vocabulary = NOTE_VOCABULARY) {
-    const entry = vocabulary?.[currentType(type)];
+    const entry = vocabulary?.[type];
     if (!entry || !Object.hasOwn(entry, "subTypes")) return undefined;
     return entry.subTypes;
 }

package/engine/number-words.mjs

@@ -1,4 +1,15 @@
-/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * 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
+ */
 
 /** English cardinal words for finite whole numbers. */
 const ONES = [

package/engine/pack-config.mjs

@@ -14,7 +14,7 @@
 /**
  * The resolved package-build configuration the pack pipeline reads.
  *
- * One module, one import: everything the compilers used to hard-code — the
+ * One module, one import: everything the compilers need — the
  * content package, the Foundry package and its kind, every path, the `_stats`
  * identity, the item-type membership, and the pack list — arrives from the
  * consuming repository's `package-build.config.yaml`.
@@ -123,11 +123,7 @@ export const CONFIG_BASENAME = "package-build.config";
  * the order the names are *reported* in, which is the order a reader should
  * reach for them: YAML first, `.mjs` last.
  *
- * The `package-build.config.*` stem this package read before the two toolchains
- * merged is **not** resolved. 3.0.0 renames the file rather than accepting both:
- * a deprecation window here would mean a repository could sit indefinitely on a
- * name for a package that no longer exists, and the upgrade already requires
- * touching the consumer's manifest and imports.
+ * Only the `package-build.config.*` stem is resolved.
  *
  * @type {readonly string[]}
  */
@@ -142,7 +138,7 @@ export const CONFIG_FILENAMES = Object.freeze([
  *
  * **Two of them in one directory is an error.** Picking one by precedence would
  * mean a repository mid-conversion silently builds from the file its author is
- * no longer editing, and the build would look entirely healthy while doing it.
+ * not editing, and the build would look entirely healthy while doing it.
  * The walk continues past a directory holding none, so a repository may still
  * sit inside one that has its own.
  *
@@ -163,7 +159,7 @@ export function findConfigFile(from) {
                 `package-build: ${dir} holds more than one configuration ` +
                     `(${found.map((f) => path.basename(f)).join(", ")}). A ` +
                     `repository declares its build in exactly one file — ` +
-                    `delete the one you are no longer editing.`,
+                    `delete the one you are not using.`,
             );
         }
         if (found.length === 1) return found[0];
@@ -267,8 +263,8 @@ function readPackageJson(rootDir) {
     } catch (err) {
         throw new Error(
             `package-build: ${manifestPath} could not be read, and the ` +
-                `configuration derives its Foundry package id, system version, ` +
-                `homepage and author from it.`,
+                `configuration derives its Foundry package id, system version ` +
+                `and homepage from it.`,
             { cause: err },
         );
     }
@@ -555,24 +551,18 @@ export function configFromData(data, configPath) {
         input.foundryPackage = foundryPackageId(rootDir);
     }
 
-    // `homepage` and `author` are the same kind of fact, transcribed the same
-    // way, and read regardless of `packageKind`: a documentation package
-    // publishes a site too, and needs both for it.
-    for (const [field, label] of [
-        ["homepage", "`homepage`"],
-        ["author", "`author`"],
-    ]) {
-        if (input[field] !== undefined) {
-            throw new Error(
-                `package-build: ${configPath} declares \`${field}\`, which a data ` +
-                    `configuration may not: it is \`package.json\`'s own ${label}. ` +
-                    `Remove the key.`,
-            );
-        }
+    // `homepage` is `package.json`'s own, transcribed, and read regardless of
+    // `packageKind`: a documentation package publishes a site too, and needs
+    // it for that.
+    if (input.homepage !== undefined) {
+        throw new Error(
+            `package-build: ${configPath} declares \`homepage\`, which a data ` +
+                `configuration may not: it is \`package.json\`'s own \`homepage\`. ` +
+                `Remove the key.`,
+        );
     }
     const { pkg } = readPackageJson(rootDir);
     if (pkg.homepage !== undefined) input.homepage = pkg.homepage;
-    if (pkg.author !== undefined) input.author = pkg.author;
 
     if (input.itemBuilders !== undefined) {
         const declared = input.itemBuilders;

package/engine/pack-router.mjs

@@ -15,14 +15,10 @@
  * Which pack a note's document lands in, when a document type has more than
  * one.
  *
- * A repository used to be able to ship exactly one pack per document type: the
- * pipeline ran one compile pass per type and routed every note of that type
- * into that pass's pack. Editorial grouping of same-type documents into
- * separate compendiums is ordinary Foundry practice — "Core Spells" and
- * "Expanded Spells" are two Item packs — and `sohl-kethira-basic` shipped
- * three. Collapsing them is a breaking change for every existing world,
- * because a compendium UUID carries its pack name
- * (`Compendium.<pkg>.characteristics.Item.<id>`).
+ * Editorial grouping of same-type documents into separate compendiums is
+ * ordinary Foundry practice — "Core Spells" and "Expanded Spells" are two Item
+ * packs. Collapsing them breaks every existing world, because a compendium
+ * UUID carries its pack name (`Compendium.<pkg>.characteristics.Item.<id>`).
  *
  * **A note declares its pack; the configuration declares the default.** The
  * routing key is one frontmatter field, `pack:`, naming a pack from the
@@ -100,10 +96,10 @@ export class PackRoutingError extends Error {
 /**
  * The frontmatter field a note declares its pack in.
  *
- * Deliberately close to the retired `package:` and deliberately not the same
- * word: `package:` said which *distribution* owned a note — now the
- * repository's `contentPackage`, and no longer authorable — while `pack:`
- * says which *compendium* receives its document.
+ * Deliberately close to `package:` and deliberately not the same word:
+ * `package:` would say which *distribution* owns a note — that is the
+ * repository's `contentPackage`, and not authorable — while `pack:` says which
+ * *compendium* receives its document.
  */
 export const PACK_FIELD = "pack";
 
@@ -132,9 +128,7 @@ export { NO_PACK };
  */
 export function declaresNoPack(fm, system) {
     const declared =
-        system === undefined ?
-            (fm?.data?.[PACK_FIELD] ?? fm?.[PACK_FIELD])
-        :   blockDataProperty(fm, system, PACK_FIELD);
+        system === undefined ? fm?.data?.[PACK_FIELD] : blockDataProperty(fm, system, PACK_FIELD);
     return declared === NO_PACK;
 }
 
@@ -274,7 +268,7 @@ export function createPackRouter(packs) {
         const authoredInBlock = inBlock != null && inBlock !== "";
         let declared =
             system === undefined ?
-                (fm?.data?.[PACK_FIELD] ?? fm?.[PACK_FIELD])
+                fm?.data?.[PACK_FIELD]
             :   blockDataProperty(fm, system, PACK_FIELD);
         // The declaration names where the note's *own* document goes. A pass
         // writing a document derived from it — an item's prose becoming a