@heroiclands/package-build 22.26.0 → 22.27.0

package/engine/metadata-index.mjs

@@ -424,16 +424,15 @@ export function loadForeignIndexes(config, localPackages, bases = PACKAGE_BASE)
                 // the record naming a path at all.
                 asset: record.asset ?? undefined,
                 // What a place is next to, reachable from and within, and
-                // what an affiliation holds, carried so a consumer's lint
+                // which affiliation governs it, carried so a consumer's lint
                 // checks a border across the package boundary from both ends,
                 // a consumer's map draws the dependency's places beside its
                 // own, and a consumer's pages list what a dependency's
-                // affiliation holds and what lies within its regions. A
+                // affiliation governs and what lies within its regions. A
                 // population lets the same checks include dependency figures.
                 borders: record.data?.borders ?? undefined,
                 routes: record.data?.routes ?? undefined,
                 parents: record.data?.parents ?? undefined,
-                domains: record.data?.domains ?? undefined,
                 population: record.data?.population ?? undefined,
                 ...(Object.hasOwn(record.data ?? {}, "government") ?
                     { government: record.data.government }

package/engine/note-vocabulary.mjs

@@ -209,8 +209,7 @@ import { positionOfFrontmatterPath } from "./diagnostics.mjs";
  * @property {(note: object, opts: {index?: object}) => object[]} [check] - A
  *   check of the whole note, run by the frontmatter lint beside the field
  *   checks with the same index. For a rule that is about the note rather than
- *   one of its fields — a place's tenure is a fact about every affiliation's
- *   `domains`, and is located at the note's `type:` line.
+ *   one of its fields, located at the note's `type:` line.
  */
 
 /* --------------------------------------------------------------------- */
@@ -1090,13 +1089,6 @@ export const NOTE_VOCABULARY = Object.freeze({
                 accepts: ["place"],
                 describe: "Where the affiliation's authority sits.",
             },
-            {
-                name: "domains",
-                ...LINKS,
-                ref: "place",
-                accepts: ["place"],
-                describe: "Places over which it holds sway.",
-            },
             { name: "population", ...NUM, describe: "How many people it counts." },
             {
                 name: "economy",
@@ -1567,12 +1559,13 @@ export const NOTE_VOCABULARY = Object.freeze({
             {
                 name: "government",
                 ...LINK,
-                shape: "an affiliation Address or null",
+                shape: "an Address or null",
                 ref: "affiliation",
                 accepts: ["affiliation"],
                 nullText: "Complete anarchy",
                 describe:
-                    "The governing affiliation; explicit null means complete anarchy. " +
+                    "The governing affiliation Address; the default target type is affiliation. " +
+                    "Explicit null means complete anarchy. " +
                     "A positive population with no government key produces an advisory.",
             },
             {
@@ -1868,3 +1861,15 @@ export function subTypes(type, vocabulary = NOTE_VOCABULARY) {
     if (!entry || !Object.hasOwn(entry, "subTypes")) return undefined;
     return entry.subTypes;
 }
+
+/**
+ * Accepted migration input with no canonical field or emitted value.
+ *
+ * Legacy affiliation domains are ignored. They never supply a government.
+ * @param {string} type - The note type.
+ * @param {string} key - An authored data key.
+ * @returns {boolean} Whether the obsolete key is accepted during migration.
+ */
+export function isLegacyDataField(type, key) {
+    return currentType(type) === "affiliation" && key === "domains";
+}

package/engine/pdf-build.mjs

@@ -745,7 +745,7 @@ export async function buildPdf({
      * @returns {string} Typst markup.
      */
     const figureCounts = { code: 0, table: 0, figure: 0, map: 0, poem: 0, prose: 0 };
-    // The role lookup a `:::figure` fence's `map` counter reaches through —
+    // The role lookup a captioned item's `map` counter reaches through —
     // see `engine/content-figures.mjs`'s `resolveRole`. Addressed form, for a
     // page's own scan below, which runs before its embeds are rewritten into
     // ordinary images; `pathRoles` is the same lookup keyed by the pathname

package/engine/pdf-render.mjs

@@ -85,10 +85,13 @@ export const BOOK_IMAGE_WIDTHS = Object.freeze({
     xlarge: "8cm",
     "full-width": '"full-width"',
 });
+import { markupAnchorFindings } from "./anchors.mjs";
 import { slugify } from "./content-slug.mjs";
+import { alertMarkdownPlugin, scanAlerts, ALERT_TYPES } from "./content-alerts.mjs";
+import { spanMarkdownPlugin, scanSpans } from "./content-spans.mjs";
 import { scanFigures } from "./content-figures.mjs";
 import { BLOCK_CONTAINERS, scanBlocks, BLOCK_NAMES } from "./content-blocks.mjs";
-import { inlineVerse, poetryStanzas } from "./content-poetry.mjs";
+import { inlineVerse, poetryStanzas, scanPoetry } from "./content-poetry.mjs";
 import { matchAllOutsideCode, replaceOutsideCode } from "./code-fences.mjs";
 import { HTML_TAG, htmlMessage } from "./content-html.mjs";
 import { EXPRESSION } from "./markdown-expressions.mjs";
@@ -108,9 +111,7 @@ import {
  * a class and let CSS decide.
  */
 const BLOCK_PRINT = Object.freeze({
-    info: Object.freeze({ color: "#2f6f9f", background: "#eef6fb", symbol: "i" }),
     secret: Object.freeze({ color: "#5c4b8a", background: "#f2eefb", symbol: "!" }),
-    warn: Object.freeze({ color: "#9a6700", background: "#fff5db", symbol: "!" }),
 });
 
 import {
@@ -197,6 +198,24 @@ export function labelFor(anchor) {
 export function createParser(registry) {
     const md = new MarkdownIt({ html: false, linkify: false, typographer: false });
     md.use(footnotePlugin);
+    md.use(alertMarkdownPlugin);
+    md.use(spanMarkdownPlugin);
+    // Verse is held inside a literal fence. Parse its inline content before
+    // footnote_tail collects definitions, using the surrounding note's env.
+    md.core.ruler.after("inline", "poetry_inline", (state) => {
+        for (const token of state.tokens) {
+            if (token.type !== "fence" || !/^poetry(?:\s|$)/.test(token.info?.trim() || ""))
+                continue;
+            token.meta ??= {};
+            token.meta.poetryStanzas = poetryStanzas(token.content).map((stanza) =>
+                stanza.map(({ text, level }) => {
+                    const children = [];
+                    state.md.inline.parse(inlineVerse(text), state.md, state.env, children);
+                    return { children, level };
+                }),
+            );
+        }
+    });
     md.use(deflistPlugin);
     md.use(iconPlugin(registry));
     // The same plugin the HTML surfaces use, so one directive is read once and
@@ -298,7 +317,7 @@ function offsetPosition(source, offset, opts = {}) {
  *   those passes did not run — `opts.prepared` — because each of them leaves the
  *   markup as written when it fails and has already said so in its own words.
  *
- * A `:::` block and a `:::figure` are the pair this pass does handle, and their
+ * A fenced div and a leading caption are the structures this pass handles, and their
  * own scanners decide what is well formed; their findings are reported here so
  * that a front-matter file, a prose file and a note body all get them.
  *
@@ -325,7 +344,7 @@ function reportUnrenderable(source, definitions, opts, original) {
     };
 
     const blocks = scanBlocks(source);
-    for (const error of blocks.errors)
+    for (const error of [...blocks.errors, ...scanAlerts(source).errors])
         report(linePosition(error.line, error.column, opts), "error", error.message);
     // A container's body, read for faults of its own — an empty box, an
     // attribute that does not parse — which the scan above passes over, because
@@ -349,6 +368,8 @@ function reportUnrenderable(source, definitions, opts, original) {
                 );
         }
     }
+    for (const error of [...scanSpans(source).errors, ...markupAnchorFindings(source)])
+        report(linePosition(error.line, error.column, opts), "error", error.message);
     for (const error of scanFigures(source).errors)
         report(linePosition(error.line, error.column, opts), "error", error.message);
     // An image sharing its paragraph with other text, or an address or title
@@ -527,14 +548,11 @@ export function markdownToTypst(markdown, opts = {}) {
         }
     }
     if (!opts.insideAdmonition) {
-        const figuresHoldingPoetry = scanFigures(source).figures;
+        const captionTargets = scanFigures(source).figures;
         const blocks = scanBlocks(source).blocks.filter(
             (block) =>
-                !figuresHoldingPoetry.some(
-                    (figure) =>
-                        block.name === "poetry" &&
-                        block.start >= figure.bodyStart &&
-                        block.end < figure.bodyEnd,
+                !captionTargets.some(
+                    (figure) => block.start >= figure.bodyStart && block.end < figure.bodyEnd,
                 ),
         );
         if (blocks.length) {
@@ -548,21 +566,13 @@ export function markdownToTypst(markdown, opts = {}) {
                         insideAdmonition: true,
                     }),
                 );
-                if (block.name === "poetry") {
-                    const content = poetryStanzas(block.body)
-                        .map((stanza) =>
-                            stanza
-                                .map(({ text, level }) => {
-                                    const verse = markdownToTypst(inlineVerse(text), {
-                                        ...sharedOptions,
-                                        insideAdmonition: true,
-                                    });
-                                    return `${level ? `#h(${level * 1.25}em)` : ""}${verse}`;
-                                })
-                                .join(" \\\n"),
-                        )
-                        .join("\n\n");
-                    output.push(`\n#block(width: 100%)[${content}]\n`);
+                if (block.name === "div") {
+                    const content = markdownToTypst(block.body, {
+                        ...sharedOptions,
+                        insideAdmonition: false,
+                    });
+                    const anchor = block.id ? ` <${sectionLabel(anchorPrefix, block.id)}>` : "";
+                    output.push(`\n#block(width: 100%)[${content}]${anchor}\n`);
                     cursor = block.end + 1;
                     continue;
                 }
@@ -629,7 +639,7 @@ export function markdownToTypst(markdown, opts = {}) {
                 { ...caption, imagesRemaining: { n: countImages(block) } }
             :   caption;
         const segments = [
-            caption.kind === "poem" ?
+            caption.kind !== "table" && caption.kind !== "figure" && caption.kind !== "map" ?
                 markdownToTypst(block, { ...sharedOptions, captions: undefined })
             :   renderMarkdownSegment(block, md, { ...ctx, caption: captioned }, definitions),
         ];
@@ -732,7 +742,23 @@ function renderBlock(tokens, i, out, ctx) {
         }
         case "fence":
         case "code_block": {
-            out.push(rawBlock(token.content, token.info?.trim() || ""));
+            if (token.type === "fence" && /^poetry(?:\s|$)/.test(token.info?.trim() || "")) {
+                const content = token.meta.poetryStanzas
+                    .map((stanza) =>
+                        stanza
+                            .map(({ children, level }) => {
+                                const verse = renderInline({ children }, ctx);
+                                return `${level ? `#h(${level * 1.25}em)` : ""}${verse}`;
+                            })
+                            .join(" \\\n"),
+                    )
+                    .join("\n\n");
+                const poem = scanPoetry(
+                    `${token.markup}${token.info}\n${token.content}${token.markup}`,
+                ).blocks[0];
+                const anchor = poem?.id ? ` <${sectionLabel(ctx.anchorPrefix, poem.id)}>` : "";
+                out.push(`\n#block(width: 100%)[${content}]${anchor}\n`);
+            } else out.push(rawBlock(token.content, token.info?.trim() || ""));
             return 1;
         }
         case "hr":
@@ -741,7 +767,20 @@ function renderBlock(tokens, i, out, ctx) {
         case "blockquote_open": {
             const end = matching(tokens, i, "blockquote_open", "blockquote_close");
             const inner = renderTokens(tokens.slice(i + 1, end), { ...ctx });
-            out.push(`\n#quote(block: true)[${inner}]\n\n`);
+            if (token.meta?.alert) {
+                const alert = token.meta.alert;
+                const colors = {
+                    note: "#0969da",
+                    tip: "#1a7f37",
+                    important: "#8250df",
+                    warning: "#9a6700",
+                };
+                const spec = ALERT_TYPES[alert.type];
+                const icon = `#image(bytes("${escapeTypstString(spec.svg.replace("<svg ", '<svg xmlns="http://www.w3.org/2000/svg" ').replaceAll("currentColor", colors[alert.type]))}"), format: "svg", width: 0.9em, height: 0.9em)`;
+                const anchor = alert.id ? ` <${sectionLabel(ctx.anchorPrefix, alert.id)}>` : "";
+                const box = `\n#block(width: 100%, stroke: (left: 2pt + rgb("${colors[alert.type]}")), inset: 8pt, above: 0.7em, below: 0.7em)[#text(fill: rgb("${colors[alert.type]}"), weight: "bold")[${icon} ${inlineMarkup(alert.title ?? alert.attributes?.title ?? spec.title, ctx)}]\n\n${inner}]${anchor}\n\n`;
+                out.push(alert.classes?.includes("border") ? figureBorder(box) : box);
+            } else out.push(`\n#quote(block: true)[${inner}]\n\n`);
             return end - i + 1;
         }
         case "bullet_list_open":
@@ -964,13 +1003,15 @@ function inlineMarkup(text, ctx) {
  */
 function captionMarkup(caption, ctx) {
     const label = escapeTypst(caption.label);
-    return caption.hasCaption ? `${label}: ${inlineMarkup(caption.caption, ctx)}` : label;
+    return caption.hasCaption ?
+            `${label ? `${label}: ` : ""}${inlineMarkup(caption.caption, ctx)}`
+        :   label;
 }
 
 /**
  * How many markdown images a figure's contents carry.
  *
- * A grouped figure's `///` caption describes the whole plate, not any one
+ * A grouped figure's leading caption describes the whole plate, not any one
  * picture in it, so {@link renderImage} needs to know which image is the
  * last — the one that carries the group's single label and anchor — and this
  * is the count it counts down from.
@@ -1157,6 +1198,24 @@ function renderInline(token, ctx) {
             case "code_inline":
                 out.push(inlineRaw(child.content));
                 break;
+            case "span_open": {
+                out.push("#box[");
+                break;
+            }
+            case "span_close": {
+                let depth = 1;
+                let opening;
+                for (let j = i - 1; j >= 0; j -= 1) {
+                    if (children[j].type === "span_close") depth += 1;
+                    if (children[j].type === "span_open" && --depth === 0) {
+                        opening = children[j];
+                        break;
+                    }
+                }
+                const id = opening?.attrGet?.("id");
+                out.push(`]${id ? ` <${sectionLabel(ctx.anchorPrefix, id)}>` : ""}`);
+                break;
+            }
             case "strong_open":
                 out.push("#strong[");
                 break;

package/engine/populations.mjs

@@ -14,17 +14,14 @@
 /**
  * Whether a world's population figures agree from the region down.
  *
- * A place states `data.population` and an affiliation states how many people
- * it counts. Read across the whole corpus those figures make claims about each
- * other, and four of those claims can be checked: the bodies holding a region
- * fit inside it, the regions inside it fit inside it, a settlement fits inside
- * every place that contains it, and a page citing a figure states the figure
- * that note states.
- *
- * This is {@link module:engine/holdings}'s sibling and reads the same two
- * keys — a place's `data.parents` for geography, an affiliation's
- * `data.domains` for tenure. Where that module asks whether anybody holds a
- * place, this one asks whether the numbers add up.
+ * A place states `data.population` and an affiliation states its membership
+ * population. Three claims can be checked: the regions inside a place fit
+ * inside it, a settlement fits inside every place that contains it, and a page
+ * citing a figure states the figure that note states.
+ *
+ * Geography comes from a place's `data.parents`. Government is independent:
+ * an affiliation's membership population does not state the population of the
+ * territory it governs, so these checks do not compare the two.
  *
  * **Every finding is a warning.** A figure out of step with its neighbours is
  * a thing an author wants to see while the note is open, and the same gap can
@@ -39,10 +36,9 @@
  * **A stated figure is compared; an absent one is not.** A place or an
  * affiliation with no `population` contributes nothing to a sum and is never
  * the subject of a finding, so a half-written corpus is quiet rather than
- * noisy. A dependency's places and affiliations take part in the *structure* —
- * a fetched entry carries the `parents` and `domains` its record stated — and
- * a fetched index carries no figure, so a dependency's people are counted
- * nowhere.
+ * noisy. A dependency's places and affiliations take part when their fetched
+ * entry supplies a population figure; an older index without one contributes
+ * no population.
  *
  * **There is deliberately no urban-share rule.** A share computed from the
  * named settlements against a region's total measures nothing: the settlement
@@ -81,14 +77,6 @@ export const POPULATION_TOLERANCE = 1.05;
  * @type {ReadonlyArray<{name: string, describe: string}>}
  */
 export const POPULATION_RULES = Object.freeze([
-    Object.freeze({
-        name: "over-held land",
-        describe:
-            "The polities whose `domains` name a place count more people than the place " +
-            "states. A polity subordinate to another holding the same place is already " +
-            "counted in that polity's figure, and a settlement is exempt, its holder's " +
-            "figure counting a hinterland the settlement does not.",
-    }),
     Object.freeze({
         name: "over-full region",
         describe:
@@ -133,19 +121,16 @@ const CORPUS = new WeakMap();
  * @property {number} [population] The stated figure, absent where unstated.
  * @property {string[]} parents   A place's enclosing places, an affiliation's
  *                                superiors.
- * @property {string[]} domains   What an affiliation holds.
  */
 
 /**
- * The whole tree, indexed the three ways the rules read it.
+ * The whole tree, indexed by place, affiliation and geographical parent.
  *
  * @typedef {object} Corpus
  * @property {Map<string, PopulationNode>} places       By shortcode.
  * @property {Map<string, PopulationNode>} affiliations By shortcode.
  * @property {Map<string, string[]>} childrenOf   Place shortcode → the places
  *                                                whose `parents` name it.
- * @property {Map<string, string[]>} holdersOf    Place shortcode → the polities
- *                                                whose `domains` name it.
  * @property {Map<string, PopulationNode>} byAddress `type/shortcode` → the
  *                                                node, for the citation rule.
  *                                                Package-blind by design: a
@@ -210,7 +195,6 @@ function localNode(note) {
         title: String(fm.name?.full ?? shortcode),
         population: figureOf(data.population),
         parents: shortcodesOf(data.parents),
-        domains: type === "affiliation" ? shortcodesOf(data.domains) : [],
     };
 }
 
@@ -236,14 +220,13 @@ export function foreignNode(canonical, entry) {
         title: String(entry.name ?? shortcode),
         population: figureOf(entry.population),
         parents: shortcodesOf(entry.parents),
-        domains: type === "affiliation" ? shortcodesOf(entry.domains) : [],
     };
 }
 
 /**
  * The corpus a link index describes.
  *
- * Population containment and tenure use the same package-blind Shortcode
+ * Population containment uses the same package-blind Shortcode
  * identity as holdings and maps. Each type has one node per shortcode, with
  * local notes taking precedence over fetched entries. A fetched place can
  * attach to local geography, while its authored `parents` remains an Address.
@@ -289,18 +272,7 @@ function corpusOf(index) {
         }
     }
 
-    /** @type {Map<string, string[]>} */
-    const holdersOf = new Map();
-    for (const node of affiliations.values()) {
-        if (node.subType !== "polity") continue;
-        for (const domain of node.domains) {
-            const list = holdersOf.get(domain);
-            if (list) list.push(node.shortcode);
-            else holdersOf.set(domain, [node.shortcode]);
-        }
-    }
-
-    found = { places, affiliations, childrenOf, holdersOf, byAddress };
+    found = { places, affiliations, childrenOf, byAddress };
     CORPUS.set(index, found);
     return found;
 }
@@ -348,27 +320,6 @@ function ancestors(corpus, shortcode) {
     return out;
 }
 
-/**
- * The polities holding a place, each counted once.
- *
- * A polity subordinate to another polity that holds the same place is already
- * inside that polity's figure, so only the topmost of a chain counts.
- *
- * @param {Corpus} corpus - The corpus.
- * @param {string} shortcode - The place.
- * @returns {PopulationNode[]} The holders.
- */
-function topHolders(corpus, shortcode) {
-    const holders = corpus.holdersOf.get(shortcode) ?? [];
-    const held = new Set(holders);
-    return holders
-        .map((name) => corpus.affiliations.get(name))
-        .filter(
-            /** @returns {node is PopulationNode} */
-            (node) => Boolean(node) && !(node?.parents ?? []).some((p) => held.has(p)),
-        );
-}
-
 /**
  * The regions immediately inside a place.
  *
@@ -416,7 +367,7 @@ function atFigure(note, rule, message) {
  * runs it with the index every reference check resolves through. Without an
  * index the questions cannot be asked and nothing is reported.
  *
- * Three rules, each reported on the note being linted: `over-held land` and
+ * Two geographical rules, each reported on the note being linted:
  * `over-full region` on the place whose figure is exceeded, and
  * `oversized settlement` on the settlement that exceeds one.
  *
@@ -441,23 +392,6 @@ export function checkPopulation(note, { index } = {}) {
     const allowed = stated * POPULATION_TOLERANCE;
     const findings = [];
 
-    // A settlement is exempt: the polity holding a city-state counts the
-    // hinterland the city does not, so its figure is properly the larger.
-    if (subType !== "settlement") {
-        const holders = topHolders(corpus, shortcode);
-        const sum = holders.reduce((total, node) => total + (node.population ?? 0), 0);
-        if (sum > allowed) {
-            findings.push(
-                atFigure(
-                    note,
-                    "over-held land",
-                    `the polities holding ${title} count ${counted(sum)} people against its ` +
-                        `stated ${counted(stated)}`,
-                ),
-            );
-        }
-    }
-
     const regions = nearestRegions(corpus, shortcode);
     const inside = regions.reduce((total, node) => total + (node.population ?? 0), 0);
     if (inside > allowed) {
@@ -520,8 +454,8 @@ const CITED =
  * restated figures drift. Each is located at the figure it wrote, counting
  * repeats so two rows carrying one number land on their own lines.
  *
- * A citation naming a note this package does not hold is skipped: a fetched
- * index carries no figure, so there is nothing to disagree with.
+ * A citation naming a note with no published population figure is skipped:
+ * there is nothing to disagree with.
  *
  * Declared as the `doc` vocabulary's type-level check.
  *

package/engine/site-build.mjs

@@ -51,6 +51,7 @@
  * @module
  */
 
+import { renderAlerts, scanAlerts } from "./content-alerts.mjs";
 import { positionOfYamlPath } from "./diagnostics.mjs";
 import { decodeNoteAddresses, noteAddressContext, encodeAddresses } from "./note-addresses.mjs";
 import fs from "node:fs";
@@ -62,11 +63,12 @@ import { addressSlug } from "./content-address.mjs";
 import { protectCode } from "./code-fences.mjs";
 import { renderMarkdownExpressions } from "./markdown-expressions.mjs";
 import { expandContentTables } from "./content-tables.mjs";
+import { renderSpans, scanSpans } from "./content-spans.mjs";
 import { renderBlocks, renderWithheldSections, scanBlocks } from "./content-blocks.mjs";
 import { scanHeadingAttributes, withheldSections } from "./heading-attributes.mjs";
 import { renderFigureBlocks, scanFigures } from "./content-figures.mjs";
 import { footnoteFindings } from "./content-footnotes.mjs";
-import { collectAnchors } from "./anchors.mjs";
+import { collectAnchors, markupAnchorFindings } from "./anchors.mjs";
 import { checkImages, renderImageFigures } from "./content-images.mjs";
 import { assetPathnameKey, pathnameProblem, resolvePathname } from "./pathnames.mjs";
 import {
@@ -563,7 +565,7 @@ export function tableUniverse(pages) {
  * about every other page, known only once the whole tree has resolved — see
  * {@link module:engine/related-pages} — so an authored value is dropped the
  * way `aliases` is, and {@link renderPages} writes the derived block once it
- * holds the graph. `contains`, `held_by` and `holdings` are dropped for the
+ * holds the graph. Derived geographical and government lists are dropped for the
  * same reason — see {@link module:engine/holdings}. **So is `map`**: the
  * file a place page names is the one the build drew beside it — see
  * {@link module:engine/site-maps} — and a page with no drawing names none.
@@ -601,6 +603,7 @@ export function pageFrontmatter(page, { decorate, webSrc, artSrc }) {
         kbfolder: page.folder,
     };
     if (decorate) decorate(data, page);
+    if (data.type === "affiliation" && data.data) delete data.data.domains;
     delete data.aliases;
     delete data.related;
     for (const key of HOLDINGS_KEYS) delete data[key];
@@ -754,7 +757,7 @@ export function renderSitePage(
         return src;
     };
     const artSrc = (value, type, accepts) => artPathname(artIndex, value, type, accepts).pathname;
-    // The role lookup a `:::figure` fence's `map` counter reaches through —
+    // The role lookup a captioned item's `map` counter reaches through —
     // see `engine/content-figures.mjs`'s `resolveRole`. Addressed form, for
     // the page's own scan below, which runs before an embed is rewritten into
     // an ordinary image; `roleByWebSrc` is the same lookup keyed by the web
@@ -837,10 +840,14 @@ export function renderSitePage(
     });
     expressionErrors.push(...expressions.findings);
     const data = pageFrontmatter(page, { decorate, webSrc, artSrc });
-    const blocks = renderBlocks(protectCode(expressions.markdown, resolve), "web");
-    const figured = renderFigureBlocks(blocks.markdown, undefined, undefined, {
-        resolveRole: (address) => roleByWebSrc.get(address),
-    });
+    const figured = renderFigureBlocks(
+        protectCode(expressions.markdown, resolve),
+        undefined,
+        undefined,
+        {
+            resolveRole: (address) => roleByWebSrc.get(address),
+        },
+    );
     for (const error of figureScan.errors)
         captionErrors.push({
             file: page.file,
@@ -848,7 +855,12 @@ export function renderSitePage(
             column: error.column,
             message: error.message,
         });
-    for (const error of scanBlocks(page.body).errors)
+    for (const error of [
+        ...scanBlocks(page.body).errors,
+        ...scanAlerts(page.body).errors,
+        ...scanSpans(page.body).errors,
+        ...markupAnchorFindings(page.body),
+    ])
         secretErrors.push({
             file: page.file,
             line: (page.bodyLine ?? 1) + error.line - 1,
@@ -877,7 +889,10 @@ export function renderSitePage(
         // The disclosure is written last, over the Markdown the page ships: the
         // passes before this one carry line positions into their findings, and a
         // line inserted ahead of them would move every one of them.
-        body: renderWithheldSections(figured.markdown),
+        body: renderWithheldSections(
+            renderSpans(renderAlerts(renderBlocks(figured.markdown, "web").markdown).markdown)
+                .markdown,
+        ),
         data,
         resolved,
         tableErrors,
@@ -1053,13 +1068,26 @@ export function renderPages(pages, options) {
     }
 
     const related = relatedPages(edges, entries);
-    // What lies within a place, who holds it, and what an affiliation holds
-    // — read off `parents` and `domains` across this package and every
-    // fetched index, local notes first so they shadow a dependency's.
-    const holdings = holdingsPages([
-        ...pages.map((page) => holdingsNode(page.fm, { title: pageTitle(page), url: page.url })),
-        ...foreignHoldingsNodes(foreign?.index),
-    ]);
+    // Geography follows parents; governing-body lists follow explicit government
+    // references across this package and every fetched index.
+    const holdings = holdingsPages(
+        [
+            ...pages.map((page) =>
+                holdingsNode(page.fm, { title: pageTitle(page), url: page.url, package: page.pkg }),
+            ),
+            ...foreignHoldingsNodes(foreign?.index),
+        ],
+        {
+            governmentNodes: records
+                .filter((record) => !isGmNote(record))
+                .map((record) =>
+                    holdingsNode(record, {
+                        title: record.name?.full ?? record.shortcode,
+                        package: config?.contentPackage ?? pages[0]?.pkg,
+                    }),
+                ),
+        },
+    );
 
     let withMap = 0;
     const outputs = capture === true ? new Map() : null;

package/engine/site-preview.mjs

@@ -284,12 +284,28 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
                 });
                 const related = relatedPages(edges, entries).get(page.url);
                 if (related) result.data.related = related;
-                const holdings = holdingsPages([
-                    ...allPages.map((item) =>
-                        holdingsNode(item.fm, { title: item.name, url: item.url }),
-                    ),
-                    ...foreignHoldingsNodes(snapshot.gates.foreign.index),
-                ]);
+                const holdings = holdingsPages(
+                    [
+                        ...allPages.map((item) =>
+                            holdingsNode(item.fm, {
+                                title: item.name,
+                                url: item.url,
+                                package: item.pkg ?? config.contentPackage,
+                            }),
+                        ),
+                        ...foreignHoldingsNodes(snapshot.gates.foreign.index),
+                    ],
+                    {
+                        governmentNodes: records
+                            .filter((record) => !isGmNote(record))
+                            .map((record) =>
+                                holdingsNode(record, {
+                                    title: record.name?.full ?? record.shortcode,
+                                    package: config.contentPackage,
+                                }),
+                            ),
+                    },
+                );
                 Object.assign(result.data, holdings.get(page.url));
                 return {
                     ok: true,