@heroiclands/package-build 23.0.0 → 23.1.1

package/docs/reference/theme-pages.md

@@ -9,12 +9,12 @@ subType: reference
 
 `package-build site` writes a page's front matter; the shared Hugo theme reads
 it and draws the page around it. This reference describes that second half —
-the infobox rail, the hero band, the government and related cards, the place
-map, search, and the markup an image or a figure renders as — and names the
+the infobox rail, the hero band, the generated sections, the related card,
+search, and the markup an image or a figure renders as — and names the
 classes a consumer styles against.
 
 **None of the sections below is an authoring instruction.** `infoboxes`,
-`related`, `contains`, `governed_by`, `governed_places`, `works`, `map`, `package`, `slug`, `url`
+`related`, `package`, `slug`, `url`
 and `title` cannot be written by a note at all: a note's top-level region is
 closed and does not admit them, so each arrives already resolved by the time
 the theme sees it. Read this page when a panel is missing or a class needs
@@ -47,11 +47,18 @@ infoboxes:
           - label: Name
             kind: text
             value: Brànwâal Dôrgaar
-          - label: Affiliations
+          - label: Homes
             kind: links
             value:
-              - text: The Silent Talon Company
-                url: /thalorna/affiliation-slntlncmpny/
+              - text: Vylar
+                url: /thalorna/place-vylar/
+      - id: affiliations
+        label: Affiliations
+        layout: list
+        entries:
+          - lead: "Captain, Blade (4), of "
+            text: The Silent Talon Company
+            url: /thalorna/affiliation-slntlncmpny/
   - id: sohl
     kind: system
     system: sohl
@@ -84,6 +91,11 @@ Each layout draws under its own class:
 
 A `link` value renders as an anchor where the build reached the page, and as
 its own words where it did not; a whole `number` is set with digit grouping.
+An entry of a `runin` group or a `list` section is `{lead, text, url}`: `lead`,
+where present, is plain text set before the link, so a membership line —
+`Captain, Blade (4), of The Silent Talon Company` — links the body's name and
+nothing else. A being's memberships arrive as a `list` section of their own,
+one entry per membership, because a line already holds commas.
 
 **How the boxes are drawn.**
 
@@ -166,97 +178,46 @@ artwork where the considered answer was "none". See
 declines one; the spelling differs from the hand-authored page's, and the two
 are not interchangeable.
 
-## The containment and government card
-
-`partials/holdings.html` renders a bordered card below the body and above the
-Related card, holding up to three small tables. The build derives this front
-matter from what every _other_ page says, so the three keys are refused in a
-note and dropped if one carries them:
-
-```yaml
----
-contains: [{ title: …, url: …, type: place, subType: … }] # places within this one
-governed_by: [{ title: …, url: …, type: affiliation, subType: … }] # the governing affiliation of this place
-governed_places: [{ title: …, url: …, type: place, subType: … }] # places explicitly governed by this affiliation
----
-```
-
-A place page carries `contains` and/or `governed_by`; an affiliation page carries
-`governed_places`. Each key is tested for independently — a page carrying none of the
-three renders no card, and a page carrying one renders one table.
-
-**`url` is absent for an entry with no page of its own** — a stub note with an
-empty body, which still appears in the lists of the pages that name it. Such
-an entry's title renders as plain text; every other entry renders as a link.
-`partials/holdings/entry.html` carries the guard, the same one
-`partials/infobox/entry.html` already applies to its own `{text, url}` shape.
-
-**Within** (`contains`) and **Governed places** (`governed_places`) list places, and each is
-broken into groups by `subType`, in the closed order region, settlement, site,
-structure, feature — a `subType` outside that order, or missing entirely,
-groups last, alphabetically by its rendered label. **Governed by** (`governed_by`)
-lists affiliations, whose kinds have no fixed hierarchy to group by, so it
-stays one flat grid with the kind printed beside each name.
-
-Every grid is `repeat(auto-fill, minmax(14em, 1fr))`, the one the Related card
-uses, so a region with forty settlements stays scannable.
-
-| class                   | drawn as                                                                        |
-| ----------------------- | ------------------------------------------------------------------------------- |
-| `.holdings`             | the card                                                                        |
-| `.holdings-table`       | one of the three tables, label and body together                                |
-| `.holdings-table-label` | "Within" / "Governed by" / "Governed places"                                    |
-| `.holdings-table-grid`  | the grid of entries (Governed by; the innermost grid of Within/Governed places) |
-| `.holdings-kind-group`  | one kind's block within Within or Governed places                               |
-| `.holdings-kind-label`  | the kind label heading a group                                                  |
-| `.holdings-entry-name`  | an entry's title, linked or plain                                               |
-| `.holdings-entry-kind`  | the kind printed beside a Governed by entry                                     |
-
-A page whose front matter declares none of `contains`, `governed_by` or
-`governed_places` renders no card at all.
-
-## The "In song and story" card
-
-`partials/literature-works.html` renders a second card directly below the
-government card, listing the works of literature that name the page's subject.
-The build derives `works` from every `literature` lore note's `data.subjects`,
-including works a fetched index carries, so no note writes it:
-
-```yaml
----
-works: [{ title: …, url: …, form: … }] # works naming this page, sorted by title
----
-```
-
-`form` is the work's `data.form`, printed in parentheses beside its title, and is
-absent when the work states none. A work naming one subject twice lists once, and
-a work naming itself is not listed on its own page. An entry's `url` is absent
-for a work that publishes no page, which renders as plain text through
-`partials/holdings/entry.html`. A page no work names carries no `works` and
-renders no card.
-
-The card reuses the government card's classes, so a consumer styling one styles
-both; `.literature-works` on the `<section>` tells them apart.
-
-| class                   | drawn as                          |
-| ----------------------- | --------------------------------- |
-| `.literature-works`     | the card, beside `.holdings`      |
-| `.holdings-table-label` | "In song and story"               |
-| `.holdings-table-grid`  | the grid of works                 |
-| `.holdings-entry-name`  | a work's title, linked or plain   |
-| `.holdings-entry-kind`  | the work's form, beside its title |
-
-## The place map
-
-A place page with `map: from-<shortcode>.svg` displays a **From here** panel
-between Holdings and Related. The map is a page-bundle SVG the build draws
-from the place's authored borders and routes, and `map:` is not a key a note
-may write. Its place names link to their pages. A page with no `map` value or
-no matching bundle resource displays no panel.
-
-The drawing fits the content column and scrolls horizontally when the
-available width is narrow. The relevant classes are `.place-map`,
-`.place-map-heading`, and `.place-map-drawing`.
+## Generated sections
+
+The build appends sections to the end of a note's body before the page is
+written: what lies within a place, who governs it and what an affiliation
+governs, the events concerning the note, the works naming it, and the map
+from a place. Each is an H1 with a fixed anchor followed by ordinary
+Markdown, so the theme draws it as it draws any authored section — a heading
+in the page, an entry in the table of contents — and no partial, class or
+front-matter key is involved. The same Markdown is a page of the Foundry
+journal and a section of the book.
+
+They follow the author's text in this order, each only where it has
+something to show:
+
+| Section           | Anchor           | On                                                     | Shows                                                                                        |
+| ----------------- | ---------------- | ------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
+| Within            | `within`         | a place                                                | the places whose `data.parents` names it, a paragraph to each kind of place                  |
+| Governed by       | `governedby`     | a place                                                | the affiliation its `data.government` names, with that affiliation's kind                    |
+| Governed places   | `governedplaces` | an affiliation                                         | the places whose `data.government` names it, a paragraph to each kind of place               |
+| Chronology        | `chronology`     | a place                                                | the [event views](format-details.md#event-views)                                             |
+| Events            | `events`         | a being, an affiliation or a people                    | the event views                                                                              |
+| Accounts          | `accounts`       | an affiliation, a place or a people                    | the event views                                                                              |
+| What followed     | `followed`       | a note holding events                                  | the event views                                                                              |
+| In song and story | `insongandstory` | any note a work names                                  | the `literature` works whose `data.subjects` name the note or one of its events, with a form |
+| From here         | `fromhere`       | a place that states, or is named in, a border or route | the map drawn from the place                                                                 |
+
+An entry naming a note with a page links to it and shows the note's name; an
+entry naming a stub, which publishes no page, is its name as plain text.
+
+**The map is set inline.** The website places the drawing inside the **From
+here** section as an SVG within a `figure.note-image.note-image-full-width`,
+so its place names stay links to their pages. The drawing fits the content
+column and scrolls sideways on a narrow screen. `site.maps: false` in the
+configuration gives no place the section.
+
+**An author's own section replaces a generated one.** A note whose body
+declares a prose anchor with a section's slug — a heading such as
+`# Within {#within}`, or a block or span with that `id` — gets no generated
+section for it, and its own section is published exactly as written. This
+is the way to choose different contents for one, or to turn one off.
 
 ## The related card
 

package/engine/address-values.mjs

@@ -5,7 +5,7 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
-import { isAddressTuple, renderAddress } from "./address.mjs";
+import { isAddressTuple, readCanonicalKey, renderAddress } from "./address.mjs";
 
 /** Address-keyed properties hold typed entries rather than string object keys. */
 export class AddressEntries {
@@ -17,17 +17,137 @@ export class AddressEntries {
     }
 }
 
-/** An Address and the section within its document. */
+/** An Address and an anchor within its note, with the anchor's kind where it is known. */
 export class AddressLink {
-    /** @param {object} target - Complete tuple. @param {string} anchor - Section slug. */
-    constructor(target, anchor) {
+    /**
+     * @param {object} target - Complete tuple.
+     * @param {string} anchor - The anchor's slug.
+     * @param {"prose"|"event"|null} [kind] - The anchor's kind, or `null` where the
+     *   position that holds the link does not fix one.
+     */
+    constructor(target, anchor, kind = null) {
         if (!isAddressTuple(target)) throw new TypeError("An Address link needs a complete tuple");
         this.target = target;
         this.anchor = anchor;
+        this.kind = kind;
         Object.freeze(this);
     }
 }
 
+/** The keys of an Address as the published index writes it, and no others. */
+export const PUBLISHED_ADDRESS_KEYS = Object.freeze(["address", "anchor", "anchorKind"]);
+
+/**
+ * Whether a parsed JSON value is an Address in its published form.
+ *
+ * @param {unknown} value - A value read from a published index.
+ * @returns {boolean} Whether it is a map of exactly `address`, `anchor` and
+ *   `anchorKind`, with `address` a string.
+ */
+export function isPublishedAddress(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+    const keys = Object.keys(value);
+    return (
+        keys.length === PUBLISHED_ADDRESS_KEYS.length &&
+        PUBLISHED_ADDRESS_KEYS.every((key) => keys.includes(key)) &&
+        typeof value.address === "string"
+    );
+}
+
+/**
+ * Write typed properties in the published index's form.
+ *
+ * Every Address becomes `{ address, anchor, anchorKind }`: `address` the full
+ * canonical Address, `anchor` the anchor's slug or `null`, `anchorKind` its
+ * kind or `null`. An Address-keyed map keeps string keys — JSON has no other —
+ * and a key takes no anchor, so nothing is lost.
+ *
+ * @param {any} value - A tuple-bearing tree.
+ * @param {WeakMap<object, object>} [seen] - Shared containers in this output.
+ * @returns {any} A serializable tree.
+ */
+export function publishAddresses(value, seen = new WeakMap()) {
+    if (value && typeof value === "object" && seen.has(value)) return seen.get(value);
+    if (isAddressTuple(value))
+        return { address: renderAddress(value), anchor: null, anchorKind: null };
+    if (value instanceof AddressLink)
+        return {
+            address: renderAddress(value.target),
+            anchor: value.anchor,
+            anchorKind: value.kind ?? null,
+        };
+    if (value instanceof AddressEntries) {
+        const out = {};
+        seen.set(value, out);
+        for (const { target, value: entry } of value.entries) {
+            const key = renderAddress(target);
+            if (Object.hasOwn(out, key)) throw new Error(`Repeated Address map key: ${key}`);
+            out[key] = publishAddresses(entry, seen);
+        }
+        return out;
+    }
+    if (Array.isArray(value)) {
+        const out = [];
+        seen.set(value, out);
+        for (const entry of value) out.push(publishAddresses(entry, seen));
+        return out;
+    }
+    if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype)
+        return value;
+    const out = {};
+    seen.set(value, out);
+    for (const [key, entry] of Object.entries(value)) out[key] = publishAddresses(entry, seen);
+    return out;
+}
+
+/**
+ * Read a published index record back into typed properties: every published
+ * Address becomes a tuple, or an {@link AddressLink} where it carries an anchor.
+ *
+ * @param {any} value - A parsed record.
+ * @returns {any} The same tree, typed.
+ * @throws {Error} When a published Address is not a complete canonical one.
+ */
+export function readPublishedAddresses(value) {
+    // A record already typed in memory keeps its tuples: each is identified by
+    // the object itself, which a copy is not.
+    if (isAddressTuple(value) || value instanceof AddressLink || value instanceof AddressEntries)
+        return value;
+    if (isPublishedAddress(value)) {
+        const target = readCanonicalKey(value.address);
+        if (!isAddressTuple(target))
+            throw new Error(`Published Address is not complete: ${JSON.stringify(value.address)}`);
+        return value.anchor == null ?
+                target
+            :   new AddressLink(target, value.anchor, value.anchorKind ?? null);
+    }
+    if (Array.isArray(value)) return value.map(readPublishedAddresses);
+    if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype)
+        return value;
+    return Object.fromEntries(
+        Object.entries(value).map(([key, entry]) => [key, readPublishedAddresses(entry)]),
+    );
+}
+
+/**
+ * Write every published Address in a parsed record as a plain string — the
+ * canonical Address, with `#<anchor>` where it carries one. What the SQL tables
+ * present, so a fence compares an Address as the text an author writes.
+ *
+ * @param {any} value - A parsed record.
+ * @returns {any} The same tree with each Address a string.
+ */
+export function flattenPublishedAddresses(value) {
+    if (isPublishedAddress(value))
+        return value.anchor == null ? value.address : `${value.address}#${value.anchor}`;
+    if (Array.isArray(value)) return value.map(flattenPublishedAddresses);
+    if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype)
+        return value;
+    return Object.fromEntries(
+        Object.entries(value).map(([key, entry]) => [key, flattenPublishedAddresses(entry)]),
+    );
+}
+
 /**
  * Render typed properties at a generated-output boundary.
  * @param {any} value - A tuple-bearing tree.

package/engine/address.mjs

@@ -34,9 +34,23 @@
  *   this module and nothing here qualifies one. A field the corpus writes at
  *   both lengths is an Address; a field never written qualified is a shortcode.
  * - A **Wikilink** is `[[<Address>[#<anchor>]|<text>]]` — a different thing that
- *   *contains* an Address. The anchor and the label belong to the Wikilink and
- *   are stripped before anything here sees the value; a frontmatter field holds
- *   the same tuple with no Wikilink around it.
+ *   *contains* an Address. The label belongs to the Wikilink.
+ *
+ * ## An anchor names a place inside what an Address names
+ *
+ * Any written form may end in `#<anchor>`: `place-ironfells#sack`,
+ * `thalorna-note-place-ironfells#sack`, or `ironfells#sack` where the
+ * position supplies the type. {@link splitAnchor} is the one reader of that
+ * suffix — a Wikilink's anchor and a frontmatter field's are read by it alike —
+ * and it hands back the Address part, which {@link parseAddress} reads as it
+ * reads any other. The anchor is never part of the tuple: it names a place
+ * *within* the note the tuple names, and every anchor a note declares has one
+ * of two kinds — `prose` for one its body declares, `event` for an event's `id`
+ * ({@link module:engine/anchors}). A wikilink names a `prose` anchor only.
+ *
+ * **A frontmatter field accepts an anchor only where it declares the kinds it
+ * takes** (`anchors: ["event"]`). Every other Address field refuses one with
+ * a finding at that value.
  *
  * **How an author writes an Address is any suffix of the tuple. At the code
  * level there is one shape.**
@@ -315,6 +329,33 @@ export function parseAddress(
     return tuple;
 }
 
+/**
+ * Split a written value at its anchor.
+ *
+ * The anchor is everything after the first `#`, and the Address everything
+ * before it; both are trimmed. A value with no `#` has no `anchor` key at
+ * all, which is how a caller tells "no anchor" from `place-x#`, an empty one.
+ *
+ * @param {string} written - The value as authored, any Wikilink label removed.
+ * @returns {{address: string, anchor?: string}} The two parts.
+ */
+export function splitAnchor(written) {
+    const text = String(written ?? "");
+    const hash = text.indexOf("#");
+    if (hash === -1) return { address: text.trim() };
+    return { address: text.slice(0, hash).trim(), anchor: text.slice(hash + 1).trim() };
+}
+
+/**
+ * Whether a written value carries an anchor.
+ *
+ * @param {unknown} written - The value as authored.
+ * @returns {boolean} Whether it is a string holding a `#`.
+ */
+export function hasAnchor(written) {
+    return typeof written === "string" && written.includes("#");
+}
+
 /** The values created by the Address reader, distinct from authored mappings. */
 const TUPLES = new WeakSet();
 

package/engine/anchors.mjs

@@ -12,7 +12,13 @@
  */
 
 /**
- * The anchors a note declares on headings, captions, divs, poems and spans.
+ * The anchors a note declares on headings, captions, divs, poems and spans,
+ * and on its events.
+ *
+ * **Every anchor has a kind** — one of {@link ANCHOR_KINDS} — so a position
+ * that accepts an anchor can say which kinds it takes: a `follows` edge names
+ * an `event`, and a wikilink a `prose` anchor. **A note has one namespace**: its event `id`s
+ * sit beside its body anchors, and a slug two of them share is a finding.
  *
  * **A leaf, deliberately.** This is asked by the link checker, by the content
  * index, and by the builds that emit a link, and they cannot all import one
@@ -37,6 +43,14 @@ import { codeRegions } from "./code-fences.mjs";
 import { slugify } from "./content-slug.mjs";
 import { scanFigures } from "./content-figures.mjs";
 import { HEADING_LINE, splitHeadingAttributes } from "./heading-attributes.mjs";
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+
+/**
+ * What an anchor marks. `prose` is every anchor the body declares — a heading,
+ * a caption, a block, an alert, a poem or a span — and `event` is the `id` of
+ * an entry in `data.events`.
+ */
+export const ANCHOR_KINDS = Object.freeze(["prose", "event"]);
 
 /**
  * The identifiers a note declares on headings, captions, divs, poems and spans.
@@ -52,8 +66,8 @@ import { HEADING_LINE, splitHeadingAttributes } from "./heading-attributes.mjs";
  *   picture's address to the role its asset declares, so a figure anchor's
  *   `name` reads `Map 1` rather than `Figure 1` where it is due — see
  *   {@link module:engine/content-figures.scanFigures}.
- * @returns {Array<{slug: string, name: string, level: number, line: number}>}
- *   In document order.
+ * @returns {Array<{slug: string, name: string, level: number, line: number,
+ *   kind: string}>} In document order.
  */
 export function collectAnchors(body, bodyLine = 1, resolveRole) {
     const anchors = [];
@@ -76,6 +90,7 @@ export function collectAnchors(body, bodyLine = 1, resolveRole) {
             name: attributes.text,
             level: heading[1].length,
             line: bodyLine + i,
+            kind: "prose",
         });
     }
     for (const figure of scanFigures(body, { resolveRole }).figures) {
@@ -85,6 +100,7 @@ export function collectAnchors(body, bodyLine = 1, resolveRole) {
             name: figure.label || figure.caption,
             level: 1,
             line: bodyLine + figure.line - 1,
+            kind: "prose",
         });
     }
     const blockAnchors = (source, firstLine) => {
@@ -96,6 +112,7 @@ export function collectAnchors(body, bodyLine = 1, resolveRole) {
                     name: block.title || block.id,
                     level: 0,
                     line: firstLine + block.start,
+                    kind: "prose",
                 });
             blockAnchors(
                 sourceLines.slice(block.start + 1, block.end).join("\n"),
@@ -111,6 +128,7 @@ export function collectAnchors(body, bodyLine = 1, resolveRole) {
                 name: alert.title,
                 level: 0,
                 line: bodyLine + alert.start,
+                kind: "prose",
             });
     }
     for (const poem of scanPoetry(body).blocks) {
@@ -120,6 +138,7 @@ export function collectAnchors(body, bodyLine = 1, resolveRole) {
                 name: poem.id,
                 level: 0,
                 line: bodyLine + poem.start,
+                kind: "prose",
             });
     }
     for (const span of scanSpans(body).spans) {
@@ -129,6 +148,7 @@ export function collectAnchors(body, bodyLine = 1, resolveRole) {
                 name: span.text,
                 level: 0,
                 line: bodyLine + span.line - 1,
+                kind: "prose",
             });
     }
     return anchors.sort((a, b) => a.line - b.line);
@@ -158,3 +178,83 @@ export function markupAnchorFindings(body) {
     }
     return errors;
 }
+
+/**
+ * The anchors a note's events declare: one per `data.events` entry carrying
+ * an `id`, at the line its `id` is written on.
+ *
+ * The `id` is taken as written — {@link module:engine/note-events} holds it to
+ * the address-segment charset — and named by the note's own name for the event
+ * when one is given, else by its summary.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {string} [raw] - The note's full text, for the line; without it the
+ *   line is omitted rather than guessed.
+ * @returns {Array<{slug: string, name: string, level: number, line?: number,
+ *   kind: "event"}>} In entry order.
+ */
+export function eventAnchors(fm, raw) {
+    const events = fm?.data?.events;
+    if (!Array.isArray(events)) return [];
+    const out = [];
+    events.forEach((entry, position) => {
+        if (!entry || typeof entry !== "object" || typeof entry.id !== "string" || !entry.id)
+            return;
+        const named =
+            Array.isArray(entry.names) ? entry.names.find((n) => n?.name)?.name : undefined;
+        const { line } =
+            raw ? positionOfFrontmatterPath(raw, ["data", "events", position, "id"]) : {};
+        out.push({
+            slug: entry.id,
+            name: String(named ?? entry.summary ?? entry.id),
+            level: 0,
+            ...(line ? { line } : {}),
+            kind: "event",
+        });
+    });
+    return out;
+}
+
+/**
+ * Event `id`s that repeat one of the note's body anchors.
+ *
+ * A note's anchors are one namespace, so `place-ironfells#sack` names one
+ * thing whether `sack` is a heading or an event. Two body anchors that collide
+ * are reported by the scanners that read them, and two events sharing an `id`
+ * by the event check; this reports the remaining case, an event against a body
+ * anchor, at the event's `id`.
+ *
+ * @param {{file: string, fm: object, raw?: string, body?: string}} note - The
+ *   note, as the link index hands it over.
+ * @returns {object[]} Findings, each at the colliding `id`.
+ */
+export function noteAnchorFindings(note) {
+    const events = eventAnchors(note.fm, note.raw);
+    if (!events.length) return [];
+    const body =
+        typeof note.body === "string" ?
+            note.body
+        :   String(note.raw ?? "").replace(/^---\n[\s\S]*?\n---\n?/, "");
+    const taken = new Map();
+    for (const anchor of collectAnchors(body)) {
+        const slug = slugify(anchor.slug);
+        if (!taken.has(slug)) taken.set(slug, anchor);
+    }
+    const findings = [];
+    const entries = note.fm.data.events;
+    for (const event of events) {
+        const other = taken.get(slugify(event.slug));
+        if (!other) continue;
+        const position = entries.findIndex((entry) => entry?.id === event.slug);
+        findings.push({
+            file: note.file,
+            ...positionOfFrontmatterPath(note.raw ?? "", ["data", "events", position, "id"]),
+            severity: "error",
+            message:
+                `\`data.events.${position}.id\` ${event.slug} is already a prose anchor ` +
+                "in this note — a note's anchors are one namespace, so an event's `id` " +
+                "differs from every heading, caption and block slug",
+        });
+    }
+    return findings;
+}

package/engine/art-slots.mjs

@@ -29,7 +29,7 @@
 /**
  * What every art slot accepts, whichever type it defaults to.
  *
- * A sound is not art: `audio` is refused at all four slots, and every slot
+ * A sound is not art: `audio` is refused at every slot, and every slot
  * that defaults to `icon` or to `image` accepts either — the corpus is why:
  * `sohl-kethira-basic` writes a deity's profile art as `icon: image-…` twenty
  * times, one full illustration per faith tradition, and a slot refusing the
@@ -40,7 +40,7 @@
 const ART_TYPES = Object.freeze(["icon", "image"]);
 
 /**
- * The four art slots, in the order the specification tabulates them.
+ * The art slots, in the order the specification tabulates them.
  *
  * `banner` is the one that reaches no compiled document: it is the page's hero
  * image, read by the site and by nothing else. The book's section plates read a
@@ -65,13 +65,6 @@ export const ART_SLOTS = Object.freeze([
         document: true,
         describe: "What a token on the canvas wears; unset, it follows `icon`.",
     }),
-    Object.freeze({
-        key: "bgImage",
-        type: "image",
-        accepts: ART_TYPES,
-        document: true,
-        describe: "A map's background art, resolved into `background.src`.",
-    }),
     Object.freeze({
         key: "banner",
         type: "image",