@heroiclands/package-build 22.28.0 → 23.1.0

package/engine/site-build.mjs

@@ -36,9 +36,9 @@
  * `/<package>/<type>-<shortcode>/`. Nothing is generated between them — no
  * section directory, no listing, no `_index.md` but the root's. An index of
  * what the package publishes is a `doc` note carrying a content table, and it
- * is authored where every other page is. The one file a page carries beside
- * itself is the map from a place — see `engine/site-maps.mjs` — and a page
- * that carries one is a leaf bundle at the same address.
+ * is authored where every other page is. Every page is one file; the map from a
+ * place is set inline in its **From here** section — see
+ * `engine/site-maps.mjs`.
  *
  * **Every gate reports; none exits.** The integrity checks a site build needs —
  * a wikilink authored in frontmatter, a name that yields no slug, an unusable
@@ -62,13 +62,14 @@ import matter from "gray-matter";
 import { addressSlug } from "./content-address.mjs";
 import { protectCode } from "./code-fences.mjs";
 import { renderMarkdownExpressions } from "./markdown-expressions.mjs";
+import { eventNoteIndex } from "./event-fields.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, markupAnchorFindings } from "./anchors.mjs";
+import { collectAnchors, eventAnchors, markupAnchorFindings } from "./anchors.mjs";
 import { checkImages, renderImageFigures } from "./content-images.mjs";
 import { assetPathnameKey, pathnameProblem, resolvePathname } from "./pathnames.mjs";
 import {
@@ -108,8 +109,9 @@ import {
 import { publishesContentPages } from "../content-config.mjs";
 import { HUGO_CONTENT } from "./site-config.mjs";
 import { homepageLinkTargets, relatedPages } from "./related-pages.mjs";
-import { HOLDINGS_KEYS, foreignHoldingsNodes, holdingsNode, holdingsPages } from "./holdings.mjs";
-import { drawSiteMaps } from "./site-maps.mjs";
+import { drawSiteMaps, inlineDrawingFigure } from "./site-maps.mjs";
+import { generatedDrawing, markGenerated, splitGenerated } from "./generated-sections.mjs";
+import { IMAGE_PATTERN } from "./content-images.mjs";
 
 const require = createRequire(import.meta.url);
 
@@ -565,10 +567,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. 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.
+ * holds the graph.
  *
  * @param {object} page - The page.
  * @param {object} options
@@ -603,11 +602,8 @@ 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];
-    delete data.map;
     if (webSrc && artSrc) resolveArtFields(data, webSrc, artSrc);
     return data;
 }
@@ -680,20 +676,11 @@ function isPlainObject(value) {
  * `doc` note's `subType` may be spelled the same as another note's `type`, and
  * `doc-gear.md` and `weapongear-gear.md` are distinct.
  *
- * **A page that carries a file beside itself is a leaf bundle**, `<slug>/index.md`,
- * because that is the one shape under which Hugo hands a page its own
- * resources — the map from a place, inlined by the theme through
- * `.Resources.Get`. The directory is the page, not a section: it holds no
- * `_index.md`, and the page's stated `url` keeps its address exactly where the
- * flat file's was.
- *
  * @param {{slug: string}} page - The page.
- * @param {object} [opts]
- * @param {boolean} [opts.bundle=false] - Whether the page carries a resource.
  * @returns {string} The file, relative to the mount.
  */
-export function pageDestination(page, { bundle = false } = {}) {
-    return bundle ? `${page.slug}/index.md` : `${page.slug}.md`;
+export function pageDestination(page) {
+    return `${page.slug}.md`;
 }
 
 /** Transform one content page without writing the site mount. */
@@ -710,6 +697,8 @@ export function renderSitePage(
         config,
         artIndex,
         figuresByAddress = new Map(),
+        events,
+        drawings = new Map(),
     },
 ) {
     const tableErrors = [];
@@ -786,10 +775,21 @@ export function renderSitePage(
     const resolve = (text) => {
         let transformed = pass.beforeLinks ? pass.beforeLinks(text, page) : text;
         transformed = resolveWebWikilinks(transformed, ctx);
-        return renderImageFigures(transformed, webSrcWithRole, lookupAsset);
+        return renderImageFigures(inlineDrawings(transformed), webSrcWithRole, lookupAsset);
     };
+    // A generated **From here** section names the drawing the build made, which
+    // the asset host does not serve: it is set inline, so its place names stay
+    // links. A drawing this build did not make is left for the image pass,
+    // which reports it.
+    const inlineDrawings = (text) =>
+        text.replace(new RegExp(IMAGE_PATTERN.source, "g"), (whole, alt, src) => {
+            const name = generatedDrawing(src);
+            const drawing = name ? drawings.get(name) : undefined;
+            if (!drawing) return whole;
+            return inlineDrawingFigure(fs.readFileSync(drawing.file, "utf8"), alt);
+        });
 
-    const { markdown, errors, lineMap } = expandContentTables(page.body, {
+    const { markdown, errors, lineMap, generatedFrom } = expandContentTables(page.body, {
         docs: universe.get(page.pkg) ?? [],
         linkable,
         source: src,
@@ -816,12 +816,14 @@ export function renderSitePage(
     // 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, {
+    ctx.eventAnchors = new Set(eventAnchors(page.fm).map((anchor) => anchor.slug));
+    const expressions = renderMarkdownExpressions(markGenerated(markdown, generatedFrom), {
         fm: page.fm,
         dates: index.dateContext,
         file: page.file,
         bodyLine: page.bodyLine,
         sqlResults: sqlTables?.inline?.get(page.file),
+        events,
         figures: {
             get: (id) => figuresById.get(id),
             // A cross-note `ref` resolves the written address exactly as a
@@ -840,14 +842,17 @@ export function renderSitePage(
     });
     expressionErrors.push(...expressions.findings);
     const data = pageFrontmatter(page, { decorate, webSrc, artSrc });
-    const figured = renderFigureBlocks(
-        protectCode(expressions.markdown, resolve),
-        undefined,
-        undefined,
-        {
-            resolveRole: (address) => roleByWebSrc.get(address),
-        },
-    );
+    // The author's text and the generated sections are resolved apart, so the
+    // links a generated section makes join no page's Related card: that card is
+    // what the authors link, and the sections already list what they derive.
+    const { authored, generated } = splitGenerated(expressions.markdown);
+    const authoredBody = protectCode(authored, resolve);
+    const authoredLinks = resolved.length;
+    const resolvedBody =
+        generated ? `${authoredBody}\n${protectCode(generated, resolve)}` : authoredBody;
+    const figured = renderFigureBlocks(resolvedBody, undefined, undefined, {
+        resolveRole: (address) => roleByWebSrc.get(address),
+    });
     for (const error of figureScan.errors)
         captionErrors.push({
             file: page.file,
@@ -894,7 +899,7 @@ export function renderSitePage(
                 .markdown,
         ),
         data,
-        resolved,
+        resolved: resolved.slice(0, authoredLinks),
         tableErrors,
         expressionErrors,
         secretErrors,
@@ -929,25 +934,23 @@ export function renderSitePage(
  * point the resolver answers, and inverted once between them. Nothing is
  * resolved twice.
  *
- * **A map is written with its page.** The drawing from a place is made before
+ * **A map is set inline in its page.** The drawing from a place is made before
  * this render — see {@link module:engine/site-maps} — and handed in keyed by
- * page URL; the page that owns one is written as a leaf bundle, the file is
- * copied beside it, and the front matter names it as `map`. Every other page
- * is written flat, and carries no such key.
+ * the file name the page's **From here** section names.
  *
  * @param {object[]} pages - Every page.
  * @param {object} options - Everything the render needs. `homepages` is the
  *   homepage as the index knows it — `{ fm, body, url, title }` — which takes
  *   no part in the render and every part in the graph: a content page links
  *   it by wikilink, and its own markdown links name content pages. `maps` is
- *   each drawing by the URL of the page that carries it.
+ *   each drawing by the file name a **From here** section names.
  * @returns {{written: number, byKind: Record<string, number>, tableErrors: object[],
  *   wikiErrors: object[], imageErrors: object[], embedErrors: object[],
  *   related: Map<string, import("./related-pages.mjs").Related>,
  *   maps: number}} `related`
  *   is keyed by page URL, and holds the homepage's block beside every content
  *   page's, so the caller can write it on the page this render does not.
- *   `maps` counts the pages written with one.
+ *   `maps` counts the pages carrying a map.
  */
 export function renderPages(pages, options) {
     const {
@@ -1007,6 +1010,14 @@ export function renderPages(pages, options) {
             figuresByAddress.set(key, byId);
     }
 
+    // Every note's events by Address, for an inline reference to an event's
+    // field — the same lookup the Foundry compile and the book build.
+    const events = eventNoteIndex(records, {
+        contentPackage: index?.contentPackage,
+        foreignIndex: foreign?.index,
+        dates: index?.dateContext,
+    });
+
     const tableErrors = [];
     const expressionErrors = [];
     const secretErrors = [];
@@ -1053,6 +1064,8 @@ export function renderPages(pages, options) {
             config,
             artIndex,
             figuresByAddress,
+            events,
+            drawings: maps,
         });
         tableErrors.push(...result.tableErrors);
         expressionErrors.push(...result.expressionErrors);
@@ -1068,42 +1081,16 @@ export function renderPages(pages, options) {
     }
 
     const related = relatedPages(edges, entries);
-    // 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;
     for (const { page, body, data } of rendered) {
         const block = related.get(page.url);
         if (block) data.related = block;
-        Object.assign(data, holdings.get(page.url));
-        const map = maps.get(page.url);
-        if (map) {
-            data.map = map.name;
-            withMap += 1;
-        }
+        if (/\{#fromhere\}/.test(sqlTables?.get(page.file)?.generated ?? "")) withMap += 1;
         if (write) {
-            const dest = path.join(outRoot, pageDestination(page, { bundle: Boolean(map) }));
+            const dest = path.join(outRoot, pageDestination(page));
             fs.mkdirSync(path.dirname(dest), { recursive: true });
-            if (map) fs.copyFileSync(map.file, path.join(path.dirname(dest), map.name));
             fs.writeFileSync(dest, matter.stringify(body, encodeAddresses(data)));
         }
         if (outputs) outputs.set(page.file, { markdown: body, frontmatter: data });
@@ -1166,7 +1153,11 @@ export function resolveSitePass(name, options) {
 export function sitePageDecorator(config, index) {
     const router = routerFor(config);
     return (data, page) => {
-        const resolvedDates = resolvedDateFields(page.fm, index.dateContext);
+        // A being's dates reach the page; a note's events reach no page.
+        const { events: _events, ...resolvedDates } = resolvedDateFields(
+            page.fm,
+            index.dateContext,
+        );
         if (Object.keys(resolvedDates).length) data.resolvedDates = resolvedDates;
         data.infoboxes = noteInfoboxes(page.fm, {
             resolve: (ref, hint) => resolveInfoboxRef(index, ref, hint),
@@ -1381,20 +1372,18 @@ export function buildSite({ config, sqlTables } = {}) {
         config: resolved,
     });
 
-    // The map from each related place, drawn now that every page is known to
-    // be addressable and before any is written, so the page writer lays each
-    // drawing beside its page. Drawn with `base`, which is what every name
-    // in a drawing links through — the same `<base><slug>/` every other href
-    // composes. Off, nothing is drawn and nothing is asked of GraphViz.
-    const drawn =
-        site.maps ?
-            drawSiteMaps({
-                records: ctx.records,
-                foreignIndex: gates.foreign.index,
-                config: resolved,
-                base,
-            })
-        :   { maps: new Map(), findings: [] };
+    // The map from each place given a From here section, drawn now that every
+    // page is known to be addressable and before any is written, so the page
+    // writer sets each drawing inline in its section. Drawn with `base`, which
+    // is what every name in a drawing links through — the same `<base><slug>/`
+    // every other href composes. With `site.maps: false` no place is given the
+    // section, nothing is drawn and nothing is asked of GraphViz.
+    const drawn = drawSiteMaps({
+        records: ctx.records,
+        foreignIndex: gates.foreign.index,
+        config: resolved,
+        base,
+    });
 
     const rendered = renderPages(pages, {
         outRoot: out,

package/engine/site-index.mjs

@@ -53,7 +53,7 @@ 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 { collectAnchors, eventAnchors } from "./anchors.mjs";
 
 import { resolveShortcodeReference } from "./shortcode-references.mjs";
 
@@ -247,6 +247,8 @@ export function buildSiteIndex(
             // 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)),
+            // The note's event ids, which a wikilink may not name.
+            eventAnchors: new Set(eventAnchors(e.fm).map((anchor) => anchor.slug)),
         };
 
         const shortcode = e.fm.shortcode;

package/engine/site-maps.mjs

@@ -12,24 +12,22 @@
  */
 
 /**
- * The maps a site build writes into its place pages.
+ * The maps a site build draws for its place pages.
  *
- * A place that states, or is named in, a border or a route has a map from it
- * — the drawing `package-build map --from` makes — and the site build draws
- * that map for every such place of this package and hands each one to the
- * page writer, which lays it beside the page as `from-<shortcode>.svg` and
- * names it in the front matter as `map`. The theme inlines it, so its place
- * names are links to their pages: every drawing is made with the site's base,
- * and every `href` in it composes `<base><slug>/` the way every other href
- * the build renders does.
+ * A place that states, or is named in, a border or a route is given a
+ * **From here** section — see {@link module:engine/derived-sections} — naming
+ * the drawing `package-build map --from` makes. The site build draws that map
+ * for every such place and sets it inline in the section, so its place names
+ * are links to their pages: every drawing is made with the site's base, and
+ * every `href` in it composes `<base><slug>/` the way every other href the
+ * build renders does.
  *
- * The npm Graphviz runtime draws each map. `site.maps: false` says the site
- * carries none and skips map rendering.
+ * The npm Graphviz runtime draws each map. `site.maps: false` gives no place
+ * the section, and nothing is drawn.
  *
  * The drawings land under `build/map/site/` — beside the author's own
  * drawings under `build/map/`, and apart from them, because the site's
- * carry links and the author's may not — and are copied from there into the
- * content mount. A build never mutates its inputs.
+ * carry links and the author's may not. A build never mutates its inputs.
  *
  * @module
  */
@@ -37,7 +35,9 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { buildMaps, relatedPlaces } from "./map-build.mjs";
+import { placesWithMaps } from "./derived-sections.mjs";
+import { fromHereFile } from "./generated-sections.mjs";
+import { buildMaps } from "./map-build.mjs";
 import { mapWorld } from "./map-places.mjs";
 
 /**
@@ -51,8 +51,7 @@ export const SITE_MAP_DIR = "build/map/site";
  * A drawing as the page writer receives it.
  *
  * @typedef {object} SiteMap
- * @property {string} name - The file's name in the page's bundle, and the
- *   value of the page's `map` key: `from-<shortcode>.svg`.
+ * @property {string} name - The file's name: `from-<shortcode>.svg`.
  * @property {string} file - Where the drawing is, absolute.
  */
 
@@ -86,7 +85,7 @@ export function inlineSvg(svg) {
 }
 
 /**
- * Draw the map from every related place of this package.
+ * Draw the map from every place of this package that is given one.
  *
  * @param {object} opts
  * @param {Array<Record<string, any>>} opts.records - The package's index
@@ -98,8 +97,8 @@ export function inlineSvg(svg) {
  *   ending in a slash: what every name in a drawing links through.
  * @returns {{maps: Map<string, SiteMap>, findings: Array<{file: string,
  *   line?: number, column?: number, severity: "error"|"warning",
- *   message: string}>}} The drawings, keyed by the URL of the page each
- *   belongs to, and warnings for relations that name no place.
+ *   message: string}>}} The drawings, keyed by the file name a **From here**
+ *   section names, and warnings for relations that name no place.
  */
 export function drawSiteMaps({ records, foreignIndex, config, base }) {
     /** @type {Map<string, SiteMap>} */
@@ -109,6 +108,8 @@ export function drawSiteMaps({ records, foreignIndex, config, base }) {
     // the map an earlier run drew.
     fs.rmSync(outDir, { recursive: true, force: true });
 
+    const centres = placesWithMaps(records, { foreignIndex, config });
+    if (centres.length === 0) return { maps, findings: [] };
     const world = mapWorld({
         records,
         foreignIndex,
@@ -116,20 +117,33 @@ export function drawSiteMaps({ records, foreignIndex, config, base }) {
         base,
         config,
     });
-    // This package's related places, which are the ones with a page here to
-    // carry a map. A dependency's place is drawn on those maps and gets none
-    // of its own from this build.
-    const centres = relatedPlaces(world.places).filter((s) => world.places.get(s)?.local);
-    if (centres.length === 0) return { maps, findings: [] };
-
     const { findings } = buildMaps({ world, outDir, from: centres });
     for (const centre of centres) {
-        const place = world.places.get(centre);
-        if (!place?.url) continue;
-        const name = `from-${centre}.svg`;
+        const name = fromHereFile(centre);
         const file = path.join(outDir, name);
         fs.writeFileSync(file, inlineSvg(fs.readFileSync(file, "utf8")));
-        maps.set(place.url, { name, file });
+        maps.set(name, { name, file });
     }
     return { maps, findings };
 }
+
+/**
+ * The figure the website sets a drawing in: the SVG inline, so its place names
+ * stay links, with no blank line inside it — a blank line would end the HTML
+ * block and hand the rest of the drawing to the Markdown renderer.
+ *
+ * @param {string} svg - The drawing, as {@link inlineSvg} wrote it.
+ * @param {string} alt - What the drawing shows, for a screen reader.
+ * @returns {string} One HTML block.
+ */
+export function inlineDrawingFigure(svg, alt) {
+    const label = String(alt ?? "").replace(/[&<>"]/g, (c) => `&#${c.charCodeAt(0)};`);
+    const body = String(svg)
+        .split("\n")
+        .filter((line) => line.trim() !== "")
+        .join("\n");
+    return (
+        `<figure class="note-image note-image-full-width" role="img" ` +
+        `aria-label="${label}">\n${body}\n</figure>`
+    );
+}

package/engine/site-preview.mjs

@@ -17,17 +17,25 @@ import { applyComputedBeingAge, presentAmongRecords } from "./being-age.mjs";
 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 {
+    attachGeneratedSections,
+    findSqlBlocks,
+    generatedSectionsFor,
+    joinGeneratedSections,
+    openNotesDatabase,
+    prepareSqlTables,
+} 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";
 import { assetAddressIndex } from "./art-fields.mjs";
+import { eventNoteIndex } from "./event-fields.mjs";
 import { frontmatterWikilinks } from "./web-wikilinks.mjs";
 import { positionOfLiteral } from "./diagnostics.mjs";
 import { addressSlug } from "./content-address.mjs";
 import { homepageTitle } from "./homepage.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
+import { drawSiteMaps } from "./site-maps.mjs";
 import {
     collectContentPages,
     collectHomepages,
@@ -97,7 +105,19 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
                 )
                 .map((page) => ({ source: page.file, markdown: page.body }));
             const publicRecords = records.filter((record) => !isGmNote(record));
+            const generated = await generatedSectionsFor(db, publicRecords, contentBase, {
+                foreignIndex: gates.foreign.index,
+                config,
+            });
+            joinGeneratedSections(generated, sources);
             const sqlTables = await prepareSqlTables(db, sources, { records: publicRecords });
+            attachGeneratedSections(sqlTables, generated);
+            const drawings = drawSiteMaps({
+                records,
+                foreignIndex: gates.foreign.index,
+                config,
+                base,
+            }).maps;
             const rendered = renderPages(pages, {
                 index: gates.index,
                 foreign: gates.foreign,
@@ -108,10 +128,11 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
                 config,
                 records,
                 homepages: homeEntries,
+                maps: drawings,
                 write: false,
                 capture: "graph",
             });
-            return { records, pages, homeEntries, gates, db, rendered };
+            return { records, pages, homeEntries, gates, db, rendered, drawings };
         } catch (error) {
             await db.close();
             throw error;
@@ -219,11 +240,16 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
                         },
                     );
                 }
-                const sqlTables = await prepareSqlTables(
-                    db,
-                    [{ source: absolute, markdown: body }],
-                    { records: records.filter((record) => !isGmNote(record)) },
-                );
+                const publicRecords = records.filter((record) => !isGmNote(record));
+                const sources = [{ source: absolute, markdown: body }];
+                const generated = await generatedSectionsFor(db, publicRecords, contentBase, {
+                    only: absolute,
+                    foreignIndex: snapshot.gates.foreign.index,
+                    config,
+                });
+                joinGeneratedSections(generated, sources);
+                const sqlTables = await prepareSqlTables(db, sources, { records: publicRecords });
+                attachGeneratedSections(sqlTables, generated);
                 const allPages = snapshot.pages.map((item) =>
                     item.file === absolute ? page : item,
                 );
@@ -240,6 +266,12 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
                         foreign: snapshot.gates.foreign,
                         types: index.contentTypes,
                     }),
+                    events: eventNoteIndex(records, {
+                        contentPackage: index.contentPackage,
+                        foreignIndex: snapshot.gates.foreign?.index,
+                        dates: index.dateContext,
+                    }),
+                    drawings: snapshot.drawings,
                 });
                 for (const error of result.tableErrors)
                     findings.push({
@@ -284,29 +316,6 @@ 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,
-                                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,
                     markdown: result.body,

package/engine/social-ties.mjs

@@ -127,7 +127,8 @@ export function checkSocialTies(note, { index } = {}) {
                 });
             }
         }
-        if (!TERMS.has(term))
+        // A term that is not text is the inner-key check's finding.
+        if ((typeof term === "string" || term === null || term === undefined) && !TERMS.has(term))
             findings.push({
                 ...at(sourceKey),
                 message: `data.socialTies value ${JSON.stringify(term)} must be one of ${SOCIAL_TIES.map(({ term: value }) => value).join(", ")}`,