@heroiclands/package-build 22.20.0 → 22.22.0

package/engine/rank-ladder.mjs

@@ -0,0 +1,198 @@
+/*
+ * 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
+ */
+
+/**
+ * What a **rung** of an affiliation's rank ladder has to state.
+ *
+ * A rung is a map of `level`, `title` and `description`, all three required,
+ * plus an optional `lore` Address for a standing that needs more said about it
+ * than a description can hold. Those three keys together are a complete
+ * statement of a rung; nothing further is needed for a ladder to be correct.
+ *
+ * **A level belongs to one rung.** The ladder is read by level, so two rungs
+ * claiming one level leave a member's `rank` answering to whichever is written
+ * first — a standing whose name changes when two lines swap places. A body that
+ * confers two titles at one standing writes them as one rung, or gives each its
+ * own level.
+ *
+ * **The severity is error**, because the ladder is what a being's `rank`
+ * indexes into: a rung missing its `title` makes a standing that resolves to
+ * nothing, and one missing its `description` ships a rung that says nothing on
+ * a sheet or a page.
+ *
+ * Two things are deliberately **not** checked here, because something else
+ * already does and a finding reported twice is a finding read once and fixed
+ * neither time:
+ *
+ * - **that `ranks` is a list at all** — the field declares `kind: "list"`, and
+ *   the shape check names it;
+ * - **that `lore` resolves** — the reference checker reads every Address in the
+ *   note, this one included.
+ *
+ * @module
+ */
+
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+
+/** The keys a rung may carry. */
+const RUNG_KEYS = Object.freeze(["level", "title", "description", "lore"]);
+
+/** The keys a rung must carry a value for. */
+const REQUIRED_TEXT = Object.freeze(["title", "description"]);
+
+/**
+ * Whether a value is a YAML mapping rather than a list or a scalar.
+ *
+ * @param {unknown} value - What was authored.
+ * @returns {boolean} True for a mapping.
+ */
+function mapping(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * Whether a value states a whole number.
+ *
+ * A quoted `"3"` counts, because YAML hands a quoted scalar back as a string
+ * and the ladder reads it as a number either way — `3.5` does not, because a
+ * rung sits on a rung and there is nothing between two of them.
+ *
+ * @param {unknown} value - The authored `level`.
+ * @returns {boolean} True when it is an integer.
+ */
+function integer(value) {
+    if (typeof value === "number") return Number.isInteger(value);
+    if (typeof value !== "string" || value.trim() === "") return false;
+    return Number.isInteger(Number(value));
+}
+
+/**
+ * Whether a value states something rather than nothing.
+ *
+ * @param {unknown} value - The authored `title` or `description`.
+ * @returns {boolean} True for a non-empty string.
+ */
+function stated(value) {
+    return typeof value === "string" && value.trim() !== "";
+}
+
+/**
+ * Check one affiliation's `data.governance.ranks` against the rung contract.
+ *
+ * Each problem is its own finding, so a rung missing all three of its required
+ * keys reports three rather than the first: a reader fixing a ladder wants the
+ * whole of it in one pass.
+ *
+ * **A finding is located by the node it is about**, through the frontmatter's
+ * own YAML tree — a present-but-wrong value points at that value, and an absent
+ * key points at the rung that should have carried it, since a key that was
+ * never written has no position of its own. Where even the rung cannot be
+ * located the position is dropped rather than guessed, and the finding names
+ * the file alone.
+ *
+ * @param {object} note - The note being checked.
+ * @param {string} note.file - Its path, as a diagnostic spells it.
+ * @param {string} [note.raw] - Its source, for the position.
+ * @param {object} [note.fm] - Its parsed frontmatter.
+ * @returns {Array<{file: string, line?: number, column?: number,
+ *   severity: string, message: string}>} The findings, in authored order.
+ */
+export function checkRankLadder(note) {
+    const ranks = note.fm?.data?.governance?.ranks;
+    // Absent is the ordinary case: most bodies confer no ranks at all. A value
+    // that is not a list is the shape check's finding, not this one's.
+    if (!Array.isArray(ranks)) return [];
+
+    const findings = [];
+    const base = ["data", "governance", "ranks"];
+
+    /**
+     * One finding, located at the first of the given paths that resolves.
+     *
+     * @param {Array<Array<string|number>>} paths - Candidates, most specific
+     *   first.
+     * @param {string} message - What is wrong.
+     * @returns {void}
+     */
+    const at = (paths, message) => {
+        let position = {};
+        for (const path of paths) {
+            position = positionOfFrontmatterPath(note.raw ?? "", path);
+            if (position.line !== undefined) break;
+        }
+        findings.push({ file: note.file, ...position, severity: "error", message });
+    };
+
+    // Level → how the rung holding it is named, so a repeat can say which rung
+    // already holds the level rather than only that something does.
+    const held = new Map();
+
+    ranks.forEach((rung, index) => {
+        const rungPath = [...base, index];
+        // Named by its level where it states one, because a reader scanning a
+        // ladder of fifteen rungs knows them by level and not by position.
+        const which =
+            integer(rung?.level) ? `rank ${rung.level}` : `rank ${index + 1} of the ladder`;
+
+        if (!mapping(rung)) {
+            at([rungPath, base], `${which} must be a map of level, title and description`);
+            return;
+        }
+
+        for (const key of Object.keys(rung)) {
+            if (RUNG_KEYS.includes(key)) continue;
+            at(
+                [[...rungPath, key], rungPath],
+                `${which} has unknown key ${key}; a rung takes ${RUNG_KEYS.join(", ")}`,
+            );
+        }
+
+        if (!integer(rung.level)) {
+            at(
+                [[...rungPath, "level"], rungPath],
+                rung.level === undefined || rung.level === null ?
+                    `${which} needs a level — the rung's position on this body's own ladder`
+                :   `${which} has a level that is not a whole number`,
+            );
+        } else {
+            // A level belongs to one rung. Two rungs claiming it leave a
+            // member's `rank` answering to the one written first, so the
+            // ladder's own order decides what the standing is called and
+            // moving two lines renames it. Reported on the second rung,
+            // naming the first, because the first is the one a reader has to
+            // find to tell the two apart.
+            const level = Number(rung.level);
+            const named = stated(rung.title) ? JSON.stringify(rung.title) : which;
+            const first = held.get(level);
+            if (first === undefined) held.set(level, named);
+            else
+                at(
+                    [[...rungPath, "level"], rungPath],
+                    `rank ${level} is declared twice, as ${first} and ${named}; a level ` +
+                        `is a rung's identity and a member's rank indexes into it, so ` +
+                        `each rung states its own`,
+                );
+        }
+
+        for (const key of REQUIRED_TEXT) {
+            if (stated(rung[key])) continue;
+            at(
+                [[...rungPath, key], rungPath],
+                `${which} needs a ${key}: ` +
+                    (key === "title" ? "what the standing is called" : "what the standing is"),
+            );
+        }
+    });
+
+    return findings;
+}

package/engine/reckoning-markers.mjs

@@ -54,7 +54,7 @@ export function resolveReckoningMarkers(index, daysPerYear) {
             1,
             daysPerYear,
         );
-        const pkg = fm.package ?? note.package ?? index?.contentPackage;
+        const pkg = note.package ?? index?.contentPackage;
         const declared = [];
         for (const [position, era] of rows.entries()) {
             if (!era || typeof era.shortcode !== "string" || !era.shortcode || !fm.shortcode)

package/engine/reference-targets.mjs

@@ -8,6 +8,7 @@ import { completeAddress, ownDocumentSystem, renderAddress } from "./address.mjs
 import { NOTE_SYSTEM } from "./systems.mjs";
 import { JOURNAL_TYPES } from "./ids.mjs";
 import { hasDocEntry } from "./item-docs.mjs";
+import { standingsDigest } from "./standings.mjs";
 
 /**
  * Names and published destinations for reference presentation.
@@ -21,7 +22,18 @@ export function buildReferenceTargets(records, published = new Map()) {
     const targets = new Map();
     for (const record of records) {
         if (!record.package || !record.type || !record.shortcode) continue;
-        const value = { name: record.name?.full ?? record.name, subType: record.subType };
+        // `subType` and the standings a body confers both ride along for the
+        // same reason: a caller resolving a reference often needs to know what
+        // it found, not only where it is. A rank is a number on the *being*
+        // and what that number is called is declared on the *body*, so the
+        // ladder travels with the reference rather than being looked up a
+        // second way.
+        const standings = standingsDigest(record);
+        const value = {
+            name: record.name?.full ?? record.name,
+            subType: record.subType,
+            ...(standings ? { standings } : {}),
+        };
         const systems = new Set([ownDocumentSystem(record.type)]);
         if (JOURNAL_TYPES.has(record.type) || hasDocEntry(record.type)) systems.add(NOTE_SYSTEM);
         for (const system of systems) {

package/engine/retired-fields.mjs

@@ -58,11 +58,9 @@
  * one of them in. Every note that carried one has been moved, across four
  * repositories, and this is the third step of that retirement.
  *
- * Refusing it matters more than refusing an ordinary dead key, because top
- * level is *deliberately open*: an unrecognised key there is passed through to
- * Hugo, so a stray `traits:` would not be ignored loudly but would arrive on
- * the page as a theme parameter, checked by nothing. The whole argument for
- * `data:` being closed is the argument for refusing this.
+ * Refusing it by name rather than as an unknown key is what names the home the
+ * facts have: the finding says which `data:` key each one becomes, which an
+ * author cannot read off a list of the keys the region declares.
  *
  * `sohl.traits` is a different field that shares the name — `projectilegear`
  * declares one, and the theme's gear sidebar reads it — so the refusal is
@@ -350,8 +348,7 @@ export function traitsRetiredMessage(file) {
         (file ? ` — ${file}` : "") +
         ". A being's own description belongs in the closed container the " +
         "content format declares, where `being` declares every one of its " +
-        "keys; at the top level it was passed through to the page unchecked, " +
-        "so a misspelling became a theme parameter rather than a finding. " +
+        "keys. " +
         "`gender`, `species`, `age` and `appearance.*` move unchanged; " +
         "`traits.birthday` becomes `data.born`; three reshape — " +
         "`traits.height.m` becomes `data.height` " +
@@ -526,12 +523,10 @@ export function legacyKeyMessage(block, field, file) {
  * What a note writing a field at the **top-level key `data:` gathered it off**
  * is told.
  *
- * {@link legacyKeyMessage}'s counterpart for the other retiring position. The
- * sweep
- * did not invent the facts `data:` holds — it collected them out of the note's
- * open top level — so `portrait:` beside `img:` is the *pre-`data:`* spelling
- * of `data.portrait`, and both are read for the same reason both in-block
- * spellings are: a package moves its corpus when it is ready, not on a flag day.
+ * {@link legacyKeyMessage}'s counterpart for the other retiring position.
+ * `portrait:` beside `img:` is the bare spelling of `data.portrait`, and both
+ * are read for the same reason both in-block spellings are: a package moves its
+ * corpus when it is ready, not on a flag day.
  *
  * It says nothing about which value is emitted, because that is not what an
  * author needs from it. The value is the same either way; what the finding

package/engine/scenes.mjs

@@ -50,6 +50,10 @@ import fs from "fs";
 import path from "path";
 import log from "loglevel";
 
+// The one reader of a system block's own properties, so a scene's effect
+// references resolve from the same position the item compiler emits from.
+import { blockProperty } from "./system-block.mjs";
+
 import {
     parseMarkdownFile,
     sohlField,
@@ -235,7 +239,11 @@ export class Scenes extends BasePackCompiler {
             // `resolveNoteId(fm)` with no package, which falls back to the
             // ambient one. What remains unset is a file with no address.
             if (!fm || !fm.id) continue;
-            if (fm.shortcode && Array.isArray(fm.effects) && fm.effects.length) {
+            // The Active Effects a region behaviour may point at, read from
+            // the block that carries them onto the document — the one position
+            // the format accepts for them.
+            const effects = blockProperty(fm, "sohl", "effects");
+            if (fm.shortcode && Array.isArray(effects) && effects.length) {
                 effectsByAddress.set(`${fm.type}-${fm.shortcode}`, {
                     id: fm.id,
                     type: fm.type,
@@ -246,7 +254,7 @@ export class Scenes extends BasePackCompiler {
                     // second router is a second answer to where the document
                     // landed, resolved from the working directory.
                     pack: this.#packRouter.resolveOrNull(fm, packForType(fm.type).docType),
-                    effects: fm.effects,
+                    effects,
                 });
             }
             if (!isMapType(fm.type)) continue;
@@ -532,7 +540,6 @@ export class Scenes extends BasePackCompiler {
                     // materialise there too. The id spelling that used
                     // to cross packs verbatim is retired.
                     folder: this.folderResolver(authoredFolder, { isAddress: true }),
-                    flags: fm.flags,
                 })
             :   null;
 

package/engine/site-build.mjs

@@ -62,9 +62,11 @@ 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 { renderSecretBlocks } from "./content-secrets.mjs";
-import { renderAdmonitions, scanAdmonitions } from "./content-admonitions.mjs";
+import { renderBlocks, renderWithheldSections, scanBlocks } from "./content-blocks.mjs";
+import { scanHeadingAttributes, withheldSections } from "./heading-attributes.mjs";
 import { renderCaptionBlocks, scanCaptions } from "./content-captions.mjs";
+import { footnoteFindings } from "./content-footnotes.mjs";
+import { collectAnchors } from "./anchors.mjs";
 import { renderImageFigures } from "./content-images.mjs";
 import { pathnameProblem, resolvePathname } from "./pathnames.mjs";
 import { buildSiteIndex, resolveInfoboxRef, wikiContext } from "./site-index.mjs";
@@ -601,8 +603,7 @@ export function pageFrontmatter(page, { decorate, webSrc, artSrc }) {
 }
 
 /**
- * The title a content page publishes under: an authored `title`, else the
- * note's name.
+ * The title a content page publishes under — the note's name.
  *
  * One rule, read by the page's own front matter and by every `related` entry
  * that names the page, so a card lists a page by exactly the title its heading
@@ -612,7 +613,7 @@ export function pageFrontmatter(page, { decorate, webSrc, artSrc }) {
  * @returns {string} The title.
  */
 function pageTitle(page) {
-    return page.fm.title ?? page.name;
+    return page.name;
 }
 
 /**
@@ -704,6 +705,8 @@ export function renderSitePage(
     const expressionErrors = [];
     const secretErrors = [];
     const captionErrors = [];
+    const headingErrors = [];
+    const footnoteErrors = [];
     const wikiErrors = [];
     const imageErrors = [];
     const resolved = [];
@@ -753,11 +756,15 @@ export function renderSitePage(
         linkable,
         source: src,
         sqlTables: sqlTables?.get(page.file),
+        pageLists: sqlTables?.pageLists?.get(page.file),
         self: { fm: searchableFrontmatter(page.fm, page.pkg), path: page.relPath },
     });
     tableErrors.push(...errors);
     const captionScan = scanCaptions(markdown);
     ctx.captionLabels = new Map(captionScan.captions.map((caption) => [caption.id, caption.label]));
+    // This page's own anchors, so a `[[#slug]]` self-link is checked against
+    // what the page actually declares rather than trusted unconditionally.
+    ctx.anchors = new Set(collectAnchors(markdown).map((anchor) => anchor.slug));
     const expressions = renderMarkdownExpressions(markdown, {
         fm: page.fm,
         dates: index.dateContext,
@@ -767,9 +774,8 @@ export function renderSitePage(
     });
     expressionErrors.push(...expressions.findings);
     const data = pageFrontmatter(page, { decorate, webSrc, artSrc });
-    const secrets = renderSecretBlocks(protectCode(expressions.markdown, resolve), "web");
-    const admonitions = renderAdmonitions(secrets.markdown);
-    const captioned = renderCaptionBlocks(admonitions.markdown);
+    const blocks = renderBlocks(protectCode(expressions.markdown, resolve), "web");
+    const captioned = renderCaptionBlocks(blocks.markdown);
     for (const error of captionScan.errors)
         captionErrors.push({
             file: page.file,
@@ -777,15 +783,19 @@ export function renderSitePage(
             column: error.column,
             message: error.message,
         });
-    for (const error of renderSecretBlocks(page.body, "book").errors)
+    for (const error of scanBlocks(page.body).errors)
         secretErrors.push({
             file: page.file,
             line: (page.bodyLine ?? 1) + error.line - 1,
             column: error.column,
             message: error.message,
         });
-    for (const error of scanAdmonitions(page.body).errors)
-        secretErrors.push({
+    for (const error of scanHeadingAttributes(page.body, page.bodyLine ?? 1).errors)
+        headingErrors.push({ file: page.file, ...error });
+    for (const error of withheldSections(page.body, page.bodyLine ?? 1).errors)
+        headingErrors.push({ file: page.file, ...error });
+    for (const error of footnoteFindings(page.body))
+        footnoteErrors.push({
             file: page.file,
             line: (page.bodyLine ?? 1) + error.line - 1,
             column: error.column,
@@ -793,13 +803,18 @@ export function renderSitePage(
         });
     return {
         page,
-        body: captioned.markdown,
+        // 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(captioned.markdown),
         data,
         resolved,
         tableErrors,
         expressionErrors,
         secretErrors,
         captionErrors,
+        headingErrors,
+        footnoteErrors,
         wikiErrors,
         imageErrors,
     };
@@ -877,6 +892,8 @@ export function renderPages(pages, options) {
     const expressionErrors = [];
     const secretErrors = [];
     const captionErrors = [];
+    const headingErrors = [];
+    const footnoteErrors = [];
     const wikiErrors = [];
     const imageErrors = [];
     const byKind = {};
@@ -920,6 +937,8 @@ export function renderPages(pages, options) {
         expressionErrors.push(...result.expressionErrors);
         secretErrors.push(...result.secretErrors);
         captionErrors.push(...result.captionErrors);
+        headingErrors.push(...result.headingErrors);
+        footnoteErrors.push(...result.footnoteErrors);
         wikiErrors.push(...result.wikiErrors);
         imageErrors.push(...result.imageErrors);
         rendered.push({ page, body: result.body, data: result.data });
@@ -963,6 +982,8 @@ export function renderPages(pages, options) {
         expressionErrors,
         secretErrors,
         captionErrors,
+        headingErrors,
+        footnoteErrors,
         wikiErrors,
         imageErrors,
         related,
@@ -1131,6 +1152,8 @@ export function buildSite({ config, sqlTables } = {}) {
             expressionErrors: [],
             secretErrors: [],
             captionErrors: [],
+            headingErrors: [],
+            footnoteErrors: [],
             wikiErrors: [],
             imageErrors: [],
             mapFindings: [],
@@ -1153,6 +1176,8 @@ export function buildSite({ config, sqlTables } = {}) {
             expressionErrors: [],
             secretErrors: [],
             captionErrors: [],
+            headingErrors: [],
+            footnoteErrors: [],
             wikiErrors: [],
             imageErrors: [],
             mapFindings: [],
@@ -1201,6 +1226,8 @@ export function buildSite({ config, sqlTables } = {}) {
             expressionErrors: [],
             secretErrors: [],
             captionErrors: [],
+            headingErrors: [],
+            footnoteErrors: [],
             wikiErrors: [],
             imageErrors: [],
             mapFindings: [],
@@ -1259,6 +1286,8 @@ export function buildSite({ config, sqlTables } = {}) {
         expressionErrors: rendered.expressionErrors,
         secretErrors: rendered.secretErrors,
         captionErrors: rendered.captionErrors,
+        headingErrors: rendered.headingErrors,
+        footnoteErrors: rendered.footnoteErrors,
         wikiErrors: rendered.wikiErrors,
         imageErrors: rendered.imageErrors,
         mapFindings: drawn.findings,

package/engine/site-config.mjs

@@ -102,9 +102,18 @@ export const DISABLE_KINDS = Object.freeze(["section", "taxonomy", "term", "RSS"
  * `<span>` marking an unresolved link — and Goldmark drops raw HTML unless
  * told otherwise. A theme cannot supply this: Hugo does not merge a theme's
  * `markup` block.
+ *
+ * `extensions.taskList` is off because the format has no checkbox: Goldmark
+ * enables it by default, which is the only reason a list item opened with
+ * `[ ]` renders a `<input type="checkbox">` here and the same two characters as
+ * plain text in the pack and the book. Off, a list item's text begins right
+ * after its marker on every surface.
  */
 export const MARKUP = Object.freeze({
-    goldmark: Object.freeze({ renderer: Object.freeze({ unsafe: true }) }),
+    goldmark: Object.freeze({
+        renderer: Object.freeze({ unsafe: true }),
+        extensions: Object.freeze({ taskList: false }),
+    }),
 });
 
 /** Where the navigation is published. */

package/engine/site-index.mjs

@@ -50,6 +50,10 @@
  */
 
 import { buildReferenceTargets } from "./reference-targets.mjs";
+import { standingsDigest } from "./standings.mjs";
+// The leaf reader, shared with the content index and the link checker, so a
+// page's anchors are read once rather than re-derived a third way here.
+import { collectAnchors } from "./anchors.mjs";
 
 import { resolveShortcodeReference } from "./shortcode-references.mjs";
 
@@ -82,16 +86,24 @@ import { isDraftNote } from "./note-vocabulary.mjs";
  * @property {string} slug   URL segment.
  * @property {string} base   Source file's basename, e.g. `Climbing.md`.
  * @property {string} url    The page's published address.
+ * @property {string} [body] The note's markdown body, for its anchors. A
+ *                           content entry always carries one; absent, the
+ *                           page is indexed as declaring none.
  */
 
 /**
  * The resolved index and everything a wikilink resolver reads beside it.
  *
  * @typedef {object} SiteIndex
- * @property {Map<string, {url: string, name?: string, draft?: boolean}>} index
+ * @property {Map<string, {url: string, name?: string, draft?: boolean, anchors?: Set<string>|Record<string, string>}>} index
  *                                       Address → page. `draft` says the page
  *                                       carries the `draft` tag, which marks a
- *                                       link *into* it.
+ *                                       link *into* it. `anchors` names the
+ *                                       `{#slug}` sections it declares — a
+ *                                       `Set` for a local page, or the
+ *                                       `{slug: uuid}` map a foreign manifest
+ *                                       publishes — and is absent where
+ *                                       neither build recorded one.
  * @property {Set<string>} ambiguous     Short addresses claimed by two
  *                                       packages, and so deliberately absent
  *                                       from `index`.
@@ -218,11 +230,21 @@ export function buildSiteIndex(
         // needs to know what it found, not only where it is: an infobox groups
         // a being's skills by the family each skill note declares, and that
         // fact lives on the target rather than on the reference.
+        // The rungs and posts a body confers, carried for the same reason
+        // `subType` is: a being states a rank as a number, and what that
+        // number is called is declared on the body.
+        const standings = standingsDigest(e.fm);
         const value = {
             url: e.url,
             name: e.name,
             draft: isDraftNote(e.fm),
             ...(e.fm.subType ? { subType: e.fm.subType } : {}),
+            ...(standings ? { standings } : {}),
+            // The `{#anchor}` slugs this page declares, so a `#section`
+            // written against it can be checked rather than joined onto the
+            // URL unverified. A Set even when empty: a page that declares no
+            // anchor still has a definite answer for one an author names.
+            anchors: new Set(collectAnchors(e.body ?? "").map((anchor) => anchor.slug)),
         };
 
         const shortcode = e.fm.shortcode;
@@ -343,7 +365,13 @@ export function resolveInfoboxRef(siteIndex, ref, hint) {
             hint,
         );
         return found ?
-                { name: found.name, url: found.url, subType: found.subType, address: found.address }
+                {
+                    name: found.name,
+                    url: found.url,
+                    subType: found.subType,
+                    address: found.address,
+                    ...(found.standings ? { standings: found.standings } : {}),
+                }
             :   undefined;
     }
     const context = {
@@ -357,6 +385,13 @@ export function resolveInfoboxRef(siteIndex, ref, hint) {
     const found =
         siteIndex.referenceTargets?.get(renderAddress(tuple)) ??
         siteIndex.index?.get(renderAddress(tuple));
-    if (found) return { name: found.name, url: found.url, subType: found.subType, address: tuple };
+    if (found)
+        return {
+            name: found.name,
+            url: found.url,
+            subType: found.subType,
+            address: tuple,
+            ...(found.standings ? { standings: found.standings } : {}),
+        };
     return undefined;
 }

package/engine/site-preview.mjs

@@ -18,6 +18,7 @@ import { reckoningContext } from "./reckoning-markers.mjs";
 import { cachedMetadataIndexes, noContentIndexPackages } from "./metadata-index.mjs";
 import { buildSiteIndex } from "./site-index.mjs";
 import { openNotesDatabase, prepareSqlTables, findSqlBlocks } from "./sql-tables.mjs";
+import { findPageListBlocks } from "./page-lists.mjs";
 import { isGmNote } from "./note-vocabulary.mjs";
 import { relatedPages } from "./related-pages.mjs";
 import { holdingsNode, holdingsPages, foreignHoldingsNodes } from "./holdings.mjs";
@@ -90,9 +91,13 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
         );
         try {
             const sources = pages
-                .filter((page) => findSqlBlocks(page.body).length)
+                .filter(
+                    (page) =>
+                        findSqlBlocks(page.body).length || findPageListBlocks(page.body).length,
+                )
                 .map((page) => ({ source: page.file, markdown: page.body }));
-            const sqlTables = await prepareSqlTables(db, sources);
+            const publicRecords = records.filter((record) => !isGmNote(record));
+            const sqlTables = await prepareSqlTables(db, sources, { records: publicRecords });
             const rendered = renderPages(pages, {
                 index: gates.index,
                 foreign: gates.foreign,
@@ -214,9 +219,11 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
                         },
                     );
                 }
-                const sqlTables = await prepareSqlTables(db, [
-                    { source: absolute, markdown: body },
-                ]);
+                const sqlTables = await prepareSqlTables(
+                    db,
+                    [{ source: absolute, markdown: body }],
+                    { records: records.filter((record) => !isGmNote(record)) },
+                );
                 const allPages = snapshot.pages.map((item) =>
                     item.file === absolute ? page : item,
                 );
@@ -246,6 +253,10 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
                     findings.push({ ...error, severity: "error" });
                 for (const error of result.captionErrors)
                     findings.push({ ...error, severity: "error" });
+                for (const error of result.headingErrors)
+                    findings.push({ ...error, severity: "error" });
+                for (const error of result.footnoteErrors)
+                    findings.push({ ...error, severity: "error" });
                 for (const error of result.wikiErrors) {
                     const pos = positionOfLiteral(text, error.link, error.occurrence);
                     findings.push({
@@ -265,7 +276,7 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
                 const entries = new Map(snapshot.rendered.entries);
                 entries.delete(original.url);
                 entries.set(page.url, {
-                    title: fm.title ?? page.name,
+                    title: page.name,
                     url: page.url,
                     type: String(fm.type),
                 });
@@ -273,7 +284,7 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
                 if (related) result.data.related = related;
                 const holdings = holdingsPages([
                     ...allPages.map((item) =>
-                        holdingsNode(item.fm, { title: item.fm.title ?? item.name, url: item.url }),
+                        holdingsNode(item.fm, { title: item.name, url: item.url }),
                     ),
                     ...foreignHoldingsNodes(snapshot.gates.foreign.index),
                 ]);