@heroiclands/package-build 22.21.0 → 22.23.0

package/engine/site-build.mjs

@@ -62,12 +62,20 @@ 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 { renderCaptionBlocks, scanCaptions } from "./content-captions.mjs";
-import { renderImageFigures } from "./content-images.mjs";
-import { pathnameProblem, resolvePathname } from "./pathnames.mjs";
-import { buildSiteIndex, resolveInfoboxRef, wikiContext } from "./site-index.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 { checkImages, renderImageFigures } from "./content-images.mjs";
+import { assetPathnameKey, pathnameProblem, resolvePathname } from "./pathnames.mjs";
+import {
+    buildSiteIndex,
+    figureIndexKeys,
+    resolveCrossNoteFigures,
+    resolveInfoboxRef,
+    wikiContext,
+} from "./site-index.mjs";
 import { frontmatterWikilinks, resolveWebWikilinks } from "./web-wikilinks.mjs";
 import { loadForeignIndexes, noContentIndexPackages } from "./metadata-index.mjs";
 import { noteInfoboxes } from "./infobox-registry.mjs";
@@ -86,7 +94,8 @@ import { isNoteRecord, noteFile } from "./index-records.mjs";
 // The one statement of what an empty body means, shared with the index.
 import { isStubNote } from "./note-state.mjs";
 import { isGmNote } from "./note-vocabulary.mjs";
-import { ART_SLOTS, artPathname, assetAddressIndex } from "./art-fields.mjs";
+import { ART_SLOTS, artPathname, assetAddressIndex, pathnameRoles } from "./art-fields.mjs";
+import { embedRole } from "./content-embeds.mjs";
 import {
     HOMEPAGE_DESTINATION,
     checkHomepageCount,
@@ -601,8 +610,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 +620,7 @@ export function pageFrontmatter(page, { decorate, webSrc, artSrc }) {
  * @returns {string} The title.
  */
 function pageTitle(page) {
-    return page.fm.title ?? page.name;
+    return page.name;
 }
 
 /**
@@ -698,14 +706,18 @@ export function renderSitePage(
         sqlTables,
         config,
         artIndex,
+        figuresByAddress = new Map(),
     },
 ) {
     const tableErrors = [];
     const expressionErrors = [];
     const secretErrors = [];
     const captionErrors = [];
+    const headingErrors = [];
+    const footnoteErrors = [];
     const wikiErrors = [];
     const imageErrors = [];
+    const embedErrors = [];
     const resolved = [];
     const src = page.relPath ?? page.base;
     const ctx = wikiContext(index, {
@@ -742,10 +754,36 @@ 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 —
+    // 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
+    // address each picture that reaches `renderImageFigures` resolves to,
+    // recorded as it is resolved rather than built across the whole corpus —
+    // `webSrc` itself reports an image's own problems as a side effect, which
+    // a speculative call over every asset would misfire for one this page
+    // never names.
+    const resolveRole = (address) => embedRole(artIndex, address);
+    const pathRoles = pathnameRoles(artIndex);
+    const roleByWebSrc = new Map();
+    const webSrcWithRole = (src) => {
+        const result = webSrc(src);
+        const role = pathRoles.get(src);
+        if (role) roleByWebSrc.set(result, role);
+        return result;
+    };
+    // The picture's role and pixel size, by the address it resolved to — read
+    // before `webSrc` translates it to the page's own host. A body image is
+    // free to write the bare, own-package form, so the address is normalized
+    // to the pathname the asset index keys by first.
+    const lookupAsset = (src) => {
+        const key = assetPathnameKey(src, config);
+        return key ? artIndex?.byPath?.get(key) : undefined;
+    };
     const resolve = (text) => {
         let transformed = pass.beforeLinks ? pass.beforeLinks(text, page) : text;
         transformed = resolveWebWikilinks(transformed, ctx);
-        return renderImageFigures(transformed, webSrc);
+        return renderImageFigures(transformed, webSrcWithRole, lookupAsset);
     };
 
     const { markdown, errors, lineMap } = expandContentTables(page.body, {
@@ -753,55 +791,104 @@ 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]));
+    const figureScan = scanFigures(markdown, { resolveRole });
+    ctx.captionLabels = new Map(
+        figureScan.figures.filter((figure) => figure.id).map((figure) => [figure.id, figure.label]),
+    );
+    // What the `ref` expression helper needs beyond the label: the caption
+    // text and whether one was authored, by the same id `ctx.captionLabels`
+    // keys on.
+    const figuresById = new Map(
+        figureScan.figures
+            .filter((figure) => figure.id)
+            .map((figure) => [
+                figure.id,
+                { label: figure.label, caption: figure.caption, hasCaption: figure.hasCaption },
+            ]),
+    );
+    // 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,
         file: page.file,
         bodyLine: page.bodyLine,
         sqlResults: sqlTables?.inline?.get(page.file),
+        figures: {
+            get: (id) => figuresById.get(id),
+            // A cross-note `ref` resolves the written address exactly as a
+            // wikilink does, against every page's figures scanned before any
+            // page's expressions render — see `renderPages`.
+            note: (target) =>
+                resolveCrossNoteFigures(target, {
+                    contentTypes: index.contentTypes,
+                    packages: index.packages,
+                    noIndexPackages: index.noIndexPackages,
+                    contentPackage: index.contentPackage,
+                    siteIndexMap: index.index,
+                    figuresByAddress,
+                }),
+        },
     });
     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);
-    for (const error of captionScan.errors)
+    const blocks = renderBlocks(protectCode(expressions.markdown, resolve), "web");
+    const figured = renderFigureBlocks(blocks.markdown, undefined, undefined, {
+        resolveRole: (address) => roleByWebSrc.get(address),
+    });
+    for (const error of figureScan.errors)
         captionErrors.push({
             file: page.file,
             line: (page.bodyLine ?? 1) + (lineMap[error.line - 1]?.line ?? error.line - 1),
             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,
             message: error.message,
         });
+    // An image sharing its paragraph with other text, or an address or title
+    // the lint already refuses — asked here too, so a site build run on its
+    // own fails on the same input `renderImageFigures` otherwise renders as
+    // though the directive were absent.
+    for (const error of checkImages(page.body, page.file, { bodyLine: page.bodyLine ?? 1 }))
+        embedErrors.push(error);
     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(figured.markdown),
         data,
         resolved,
         tableErrors,
         expressionErrors,
         secretErrors,
         captionErrors,
+        headingErrors,
+        footnoteErrors,
         wikiErrors,
         imageErrors,
+        embedErrors,
     };
 }
 
@@ -840,7 +927,7 @@ export function renderSitePage(
  *   it by wikilink, and its own markdown links name content pages. `maps` is
  *   each drawing by the URL of the page that carries it.
  * @returns {{written: number, byKind: Record<string, number>, tableErrors: object[],
- *   wikiErrors: object[], imageErrors: 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
@@ -873,12 +960,47 @@ export function renderPages(pages, options) {
         types: index?.contentTypes ?? [],
     });
 
+    // Every page's own figures, by the address a `ref` crossing into it would
+    // write — scanned once, before any page's own expressions render, so a
+    // page citing another's figure finds it already numbered. Numbering stays
+    // per page: each `scanFigures` call here starts its own counters, exactly
+    // as the page's own render does, so the number a cross-note `ref` reports
+    // is the one the target's own page carries.
+    const figuresByAddress = new Map();
+    for (const page of pages) {
+        const shortcode = page.fm.shortcode;
+        if (typeof shortcode !== "string" || !shortcode) continue;
+        const src = page.relPath ?? page.base;
+        const { markdown } = expandContentTables(page.body, {
+            docs: universe.get(page.pkg) ?? [],
+            linkable,
+            source: src,
+            sqlTables: sqlTables?.get(page.file),
+            pageLists: sqlTables?.pageLists?.get(page.file),
+            self: { fm: searchableFrontmatter(page.fm, page.pkg), path: page.relPath },
+        });
+        const byId = new Map(
+            scanFigures(markdown)
+                .figures.filter((figure) => figure.id)
+                .map((figure) => [
+                    figure.id,
+                    { label: figure.label, caption: figure.caption, hasCaption: figure.hasCaption },
+                ]),
+        );
+        const type = String(page.fm.type ?? "").toLowerCase();
+        for (const key of figureIndexKeys(page.pkg, type, shortcode))
+            figuresByAddress.set(key, byId);
+    }
+
     const tableErrors = [];
     const expressionErrors = [];
     const secretErrors = [];
     const captionErrors = [];
+    const headingErrors = [];
+    const footnoteErrors = [];
     const wikiErrors = [];
     const imageErrors = [];
+    const embedErrors = [];
     const byKind = {};
     // The link graph, as `(source URL, target URL)` — read off each page's
     // resolution below, and off the homepage's markdown links.
@@ -915,13 +1037,17 @@ export function renderPages(pages, options) {
             sqlTables,
             config,
             artIndex,
+            figuresByAddress,
         });
         tableErrors.push(...result.tableErrors);
         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);
+        embedErrors.push(...result.embedErrors);
         rendered.push({ page, body: result.body, data: result.data });
         for (const hit of result.resolved) if (hit.url) edges.push([page.url, hit.url]);
     }
@@ -963,8 +1089,11 @@ export function renderPages(pages, options) {
         expressionErrors,
         secretErrors,
         captionErrors,
+        headingErrors,
+        footnoteErrors,
         wikiErrors,
         imageErrors,
+        embedErrors,
         related,
         maps: withMap,
         ...(capture ? { ...(outputs ? { outputs } : {}), edges, entries } : {}),
@@ -1015,6 +1144,7 @@ export function sitePageDecorator(config, index) {
             resolve: (ref, hint) => resolveInfoboxRef(index, ref, hint),
             router,
             dates: index.dateContext,
+            contentPackage: index.contentPackage,
         });
     };
 }
@@ -1036,7 +1166,8 @@ export function sitePageDecorator(config, index) {
  *   `sql` directive with none prepared is a table error: nothing here runs a
  *   query.
  * @returns {{gates: object, stats: object|null, tableErrors: object[],
- *   wikiErrors: object[], imageErrors: object[], mapFindings: object[],
+ *   wikiErrors: object[], imageErrors: object[], embedErrors: object[],
+ *   mapFindings: object[],
  *   manifests: object|null}} `mapFindings` is what drawing the maps found —
  *   warnings, never a reason to fail the build.
  */
@@ -1131,8 +1262,11 @@ export function buildSite({ config, sqlTables } = {}) {
             expressionErrors: [],
             secretErrors: [],
             captionErrors: [],
+            headingErrors: [],
+            footnoteErrors: [],
             wikiErrors: [],
             imageErrors: [],
+            embedErrors: [],
             mapFindings: [],
             stats: null,
         };
@@ -1153,8 +1287,11 @@ export function buildSite({ config, sqlTables } = {}) {
             expressionErrors: [],
             secretErrors: [],
             captionErrors: [],
+            headingErrors: [],
+            footnoteErrors: [],
             wikiErrors: [],
             imageErrors: [],
+            embedErrors: [],
             mapFindings: [],
             stats: {
                 homepages: writeHomepages(homeRoot, homepages, resolved),
@@ -1201,8 +1338,11 @@ export function buildSite({ config, sqlTables } = {}) {
             expressionErrors: [],
             secretErrors: [],
             captionErrors: [],
+            headingErrors: [],
+            footnoteErrors: [],
             wikiErrors: [],
             imageErrors: [],
+            embedErrors: [],
             mapFindings: [],
         };
     }
@@ -1259,8 +1399,11 @@ 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,
+        embedErrors: rendered.embedErrors,
         mapFindings: drawn.findings,
         stats: {
             ...rendered.byKind,

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

@@ -51,6 +51,9 @@
 
 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";
 
@@ -63,10 +66,12 @@ import {
     renderAddress,
     isAddressTuple,
     ownDocumentSystem,
+    expandAddress,
 } from "./address.mjs";
 import { NOTE_SYSTEM } from "./systems.mjs";
 import { contentPackage } from "./content-package.mjs";
 import { reckoningContext } from "./reckoning-markers.mjs";
+import { presentAmongRecords } from "./being-age.mjs";
 // The declared tag vocabulary, which is where `draft` is stated.
 import { isDraftNote } from "./note-vocabulary.mjs";
 
@@ -83,16 +88,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`.
@@ -229,6 +242,11 @@ export function buildSiteIndex(
             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;
@@ -261,7 +279,12 @@ export function buildSiteIndex(
 
     return {
         contentPackage: ownPackage,
-        dateContext: reckoningContext({ notes: records }),
+        // Carried on the same context `resolvedDateFields` reads: a recurring
+        // event's `next` is computed against this present.
+        dateContext: {
+            ...reckoningContext({ notes: records }),
+            present: presentAmongRecords(records),
+        },
         referenceTargets: buildReferenceTargets(records, new Map([...foreignReferences, ...index])),
         index,
         ambiguous,
@@ -272,6 +295,70 @@ export function buildSiteIndex(
     };
 }
 
+/**
+ * The address keys one page's figures are reachable by — the same two forms
+ * {@link buildSiteIndex} assigns the page itself, so a `ref` crossing into it
+ * resolves by exactly the address a wikilink would use.
+ *
+ * @param {string} pkg - The page's own content package.
+ * @param {string} type - The note's `type`.
+ * @param {string} shortcode - The note's `shortcode`.
+ * @returns {Set<string>} The short `type/shortcode` key and the canonical
+ *   `package-system-type-shortcode` one.
+ */
+export function figureIndexKeys(pkg, type, shortcode) {
+    const system = ownDocumentSystem(type);
+    const keys = new Set([
+        `${type}/${shortcode}`.toLowerCase(),
+        canonicalKey(pkg, system, type, shortcode),
+    ]);
+    if (system !== NOTE_SYSTEM) keys.add(canonicalKey(pkg, NOTE_SYSTEM, type, shortcode));
+    return keys;
+}
+
+/**
+ * Resolve a `ref` call's cross-note address to the target's own figures and
+ * its own address — the `figures.note` a `ref` helper's render context reads,
+ * built once and threaded into every page.
+ *
+ * Reads the written address exactly as a wikilink does
+ * ({@link readQualifier}, {@link expandAddress}), so a `ref` crossing into
+ * another note and a `[[…]]` link to the same note agree on what resolves and
+ * what does not: a target naming no known type or no fetched package's index
+ * is unresolved for both, and one address names one note for both.
+ *
+ * @param {string} target - The address as written, anchor already removed —
+ *   {@link module:engine/wikilink-syntax.ParsedWikilink.target}.
+ * @param {object} options
+ * @param {Set<string>} options.contentTypes - Every type this build reads as
+ *   an address qualifier.
+ * @param {Set<string>} options.packages - Every package an address may name.
+ * @param {Set<string>} options.noIndexPackages - Packages declared
+ *   `contentIndex: false`.
+ * @param {string} options.contentPackage - The package a target with no
+ *   package segment defaults to.
+ * @param {Map<string, {url: string}>} options.siteIndexMap - {@link SiteIndex}'s
+ *   own `index`, read for the target's existence and its URL.
+ * @param {Map<string, Map<string, object>>} options.figuresByAddress - Every
+ *   note's figures, by id, keyed as {@link figureIndexKeys} keys the note.
+ * @returns {{url: string, figures: Map<string, object>}|undefined} The
+ *   target's own address and figures, or `undefined` when the address names
+ *   no note this build resolves.
+ */
+export function resolveCrossNoteFigures(
+    target,
+    { contentTypes, packages, noIndexPackages, contentPackage, siteIndexMap, figuresByAddress },
+) {
+    const read = readQualifier(target, contentTypes, packages, noIndexPackages);
+    if (!read || read.reason) return undefined;
+    const key = expandAddress(read, { package: contentPackage, system: NOTE_SYSTEM });
+    const shortKey = `${read.itemDoc ? "doc" : ""}${read.type}/${read.shortcode}`.toLowerCase();
+    const entry = siteIndexMap.get(key) ?? siteIndexMap.get(shortKey);
+    if (!entry) return undefined;
+    const figures = figuresByAddress.get(key) ?? figuresByAddress.get(shortKey) ?? new Map();
+    return { url: entry.url, figures };
+}
+
 /**
  * The per-page context a wikilink resolver takes.
  *

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({
@@ -259,13 +270,15 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
                     const pos = positionOfLiteral(text, error.src, error.occurrence);
                     findings.push({ ...error, ...pos, severity: "error" });
                 }
+                for (const error of result.embedErrors)
+                    findings.push({ ...error, severity: "error" });
                 if (findings.length) return { ok: false, findings };
                 const edges = snapshot.rendered.edges.filter(([source]) => source !== original.url);
                 for (const hit of result.resolved) if (hit.url) edges.push([page.url, hit.url]);
                 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 +286,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),
                 ]);