@heroiclands/package-build 25.6.2 → 25.7.0

package/engine/preview-index.mjs

@@ -31,7 +31,7 @@ import { embedRole } from "./content-embeds.mjs";
 import { renderImageFigures } from "./content-images.mjs";
 import { runContext } from "./content-scripts.mjs";
 import { eventNoteIndex } from "./event-fields.mjs";
-import { isHomepage } from "./homepage.mjs";
+import { homepageTitle, isHomepage } from "./homepage.mjs";
 import { authoredFrontmatter, isNoteRecord, isStub } from "./index-records.mjs";
 import { noContentIndexPackages } from "./metadata-index.mjs";
 import { isGmNote } from "./note-vocabulary.mjs";
@@ -57,32 +57,56 @@ import { siteBase } from "../content-config.mjs";
  */
 
 /**
- * Build the object a preview with an index renders from.
+ * What a page of the package resolves against, from its content-index records.
+ *
+ * The site build reads the same answers from its whole tree; this derives
+ * them from the records alone, so a single note renders as its page does
+ * without the tree. Each note that publishes a page is an entry at the URL
+ * the site gives it: the homepage at the package root, a note
+ * `site.sections` names at its section, and every other at its address.
  *
  * @param {object} options
  * @param {object} options.config - The resolved package configuration.
- * @param {object[]} options.records - The content index's records: every note
- *   and every asset.
+ * @param {object[]} options.records - The content index's records.
  * @param {object} [options.foreign] - The dependencies' indexes, as
  *   {@link module:engine/metadata-index.loadForeignIndexes} returns them.
- *   Omitted, the package links only to itself.
- * @returns {PreviewIndex} The index.
+ * @param {(record: object) => object[]|undefined} [options.anchorsOf] - A
+ *   note's anchors as its page emits them, where they differ from the
+ *   record's: those of its body with its query answers and generated sections
+ *   expanded. Absent, or answering nothing, the record's own.
+ * @returns {{site: object, assets: object, events: Map<string, object>, runs: object,
+ *   pages: Map<string, object>}} The link index, the asset address space,
+ *   every note's events, the package's marked-text context, and the record
+ *   behind each page by its URL.
  */
-export function previewIndex({ config, records, foreign }) {
+export function recordSiteContext({ config, records, foreign, anchorsOf = () => undefined }) {
     const base = siteBase(config);
+    const sections = new Map(
+        Object.entries(config.site?.sections ?? {}).map(([name, address]) => [address, name]),
+    );
     const entries = [];
+    const pages = new Map();
     for (const record of records) {
         if (!isNoteRecord(record) || isStub(record)) continue;
         const fm = authoredFrontmatter(record);
         if (isGmNote(fm) || typeof fm.shortcode !== "string" || !fm.shortcode) continue;
+        const slug = addressSlug(fm);
+        const home = isHomepage(fm);
+        const url =
+            home ? base
+            : sections.has(slug) ? `${base}${sections.get(slug)}/`
+            : `${base}${slug}/`;
+        pages.set(url, record);
         entries.push({
             kind: "content",
             fm,
             body: "",
-            anchors: record.anchors ?? [],
+            anchors: anchorsOf(record) ?? record.anchors ?? [],
             pkg: record.package ?? config.contentPackage,
-            name: fm.name?.full ?? fm.shortcode,
-            url: isHomepage(fm) ? base : `${base}${addressSlug(fm)}/`,
+            name:
+                fm.name?.full ??
+                (home ? homepageTitle(fm, config) : (record.file?.name ?? fm.shortcode)),
+            url,
         });
     }
     const site = buildSiteIndex(entries, {
@@ -99,6 +123,26 @@ export function previewIndex({ config, records, foreign }) {
         foreignIndex: foreign?.index,
         dates: site.dateContext,
     });
+    const runs = runContext(config, records, {
+        referenceName: (target) => resolveInfoboxRef(site, target)?.name,
+    });
+    return { site, assets, events, runs, pages };
+}
+
+/**
+ * Build the object a preview with an index renders from.
+ *
+ * @param {object} options
+ * @param {object} options.config - The resolved package configuration.
+ * @param {object[]} options.records - The content index's records: every note
+ *   and every asset.
+ * @param {object} [options.foreign] - The dependencies' indexes, as
+ *   {@link module:engine/metadata-index.loadForeignIndexes} returns them.
+ *   Omitted, the package links only to itself.
+ * @returns {PreviewIndex} The index.
+ */
+export function previewIndex({ config, records, foreign }) {
+    const { site, assets, events, runs } = recordSiteContext({ config, records, foreign });
     const resolveRole = (address) => embedRole(assets, address);
     const webSrc = (src) =>
         pathnameProblem(src) ? src : (resolvePathname(src, config)?.web ?? src);
@@ -107,9 +151,7 @@ export function previewIndex({ config, records, foreign }) {
         return key ? assets?.byPath?.get(key) : undefined;
     };
     return {
-        runs: runContext(config, records, {
-            referenceName: (target) => resolveInfoboxRef(site, target)?.name,
-        }),
+        runs,
         icons: config.icons,
         lookupAsset,
         resolveSrc: webSrc,

package/engine/site-build.mjs

@@ -51,61 +51,49 @@
  * @module
  */
 
-import { scanPageBreaks } from "./page-breaks.mjs";
-import { scanAlerts } from "./content-alerts.mjs";
-import { positionOfYamlPath } from "./diagnostics.mjs";
-import { decodeNoteAddresses, noteAddressContext } from "./note-addresses.mjs";
 import fs from "node:fs";
 import path from "node:path";
-import { createRequire } from "node:module";
-import { readMatter } from "./note-matter.mjs";
 
 import { addressSlug } from "./content-address.mjs";
-import { expandContent } from "./content-expand.mjs";
 import { eventNoteIndex } from "./event-fields.mjs";
 import { expandContentTables } from "./content-tables.mjs";
-import { scanSpans } from "./content-spans.mjs";
-import { runContext, scanRuns } from "./content-scripts.mjs";
-import { scanBlocks } from "./content-blocks.mjs";
-import { scanHeadingAttributes, withheldSections } from "./heading-attributes.mjs";
+import { runContext } from "./content-scripts.mjs";
 import { scanFigures } from "./content-figures.mjs";
-import { footnoteFindings } from "./content-footnotes.mjs";
-import { markupAnchorFindings } from "./anchors.mjs";
-import { checkImages, renderImageFigures } from "./content-images.mjs";
-import { isAddressTuple } from "./address.mjs";
-import { assetPathnameKey, pathnameProblem, resolvePathname } from "./pathnames.mjs";
+import { resolvePathname } from "./pathnames.mjs";
 import { buildSiteIndex, figureIndexKeys, resolveInfoboxRef } from "./site-index.mjs";
-import { frontmatterWikilinks } from "./wikilinks.mjs";
 import { loadForeignIndexes, noContentIndexPackages } from "./metadata-index.mjs";
-import { noteInfoboxes } from "./infobox-registry.mjs";
 import { formatUnaddressableFinding, unaddressableForeignPackages } from "./metadata-index.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
-import { routerFor } from "./pack-router.mjs";
 import { searchableFrontmatter } from "./note-package.mjs";
 // The corpus, from the one pass that derives it.
 import { indexRecordsFor } from "./content-index.mjs";
-// A being's computed `age` — see `engine/being-age.mjs`. `pdf-build.mjs`
-// reuses `collectContentPages`'s pages, so wiring it here reaches the book too.
-import { applyComputedBeingAge } from "./being-age.mjs";
 import { normalizeCurrentDate } from "./current-date.mjs";
 import { reckoningContext } from "./reckoning-markers.mjs";
-import { resolvedDateFields } from "./note-dates.mjs";
 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 { artPathname, assetAddressIndex } from "./art-fields.mjs";
 import { embedRole } from "./content-embeds.mjs";
 import { checkHomepageCount, homepageFrontmatter, homepageTitle, isHomepage } from "./homepage.mjs";
 import { publishesContentPages, siteBase } from "../content-config.mjs";
 import { seeAlsoPages } from "./see-also.mjs";
 import { homepageLinkTargets, relatedPages } from "./related-pages.mjs";
-import { GENERATED_MARK } from "./site-reach.mjs";
-import { drawSiteMaps, inlineDrawingFigure } from "./site-maps.mjs";
-import { generatedDrawing } from "./generated-sections.mjs";
-import { IMAGE_PATTERN } from "./content-images.mjs";
+import { drawSiteMaps } from "./site-maps.mjs";
+// One page's render, shared with the single-note render of `./note-page`.
+// A being's computed `age` is applied there — see `engine/being-age.mjs`;
+// `pdf-build.mjs` reuses `collectContentPages`'s pages, so it reaches the book too.
+import {
+    contentPage,
+    isPlainObject,
+    pageFrontmatter,
+    pageTitle,
+    parseNote,
+    renderSitePage,
+    resolveArtFields,
+    resolveSitePass,
+    sitePageDecorator,
+} from "./site-page.mjs";
 
-const require = createRequire(import.meta.url);
+export { pageFrontmatter, renderSitePage, resolveSitePass, sitePageDecorator };
 
 /**
  * The content-tree files this build publishes from, in the order it emits them.
@@ -150,33 +138,13 @@ function siteCorpusFiles(contentBase, ctx) {
  * @returns {{fm: object, body: string}|null}
  */
 function readNote(file, ctx) {
-    let parsed;
     let source;
     try {
         source = fs.readFileSync(file, "utf8");
-        parsed = readMatter(source);
     } catch {
         return null;
     }
-    const context = {
-        ...noteAddressContext(ctx.config ?? {}),
-        package: ctx.contentPackage ?? ctx.config?.contentPackage,
-    };
-    try {
-        return {
-            fm: decodeNoteAddresses(parsed.data, context),
-            body: parsed.content,
-            bodyLine: source.slice(0, source.length - parsed.content.length).split("\n").length,
-        };
-    } catch (error) {
-        const position = positionOfYamlPath(parsed.matter, error.keyPath ?? [], {
-            key: error.addressKey,
-        });
-        if (position.line) position.line++;
-        error.file = file;
-        error.position = position;
-        throw error;
-    }
+    return parseNote(source, file, ctx);
 }
 
 /**
@@ -219,76 +187,19 @@ export function collectContentPages(contentBase, ctx) {
         if (ctx.only && file !== ctx.only) continue;
         const note = readNote(file, ctx);
         if (!note) continue;
-        applyComputedBeingAge(note.fm, present, dates);
-        const { fm, body, bodyLine } = note;
-        // The configuration's, never a note's: a note declares no `package:`, so every
-        // note in the tree belongs to the package this repository compiles.
-        const pkg = ctx.contentPackage;
-        if (!ctx.packages.has(pkg) || !fm.type) continue;
-        // A homepage is addressed like any other note, but it is
-        // gathered by {@link collectHomepages} rather than here: it is the
-        // whole of a homepage-only build, which never walks the tree for
-        // content pages at all.
-        if (isHomepage(fm)) continue;
-        // A stub has no body, so it has no page. Asked of the note's own text
-        // rather than of the absent address the index derived, so the site and
-        // the index apply one rule from one module and a note that cannot be
-        // addressed for some *other* reason still reaches the finding below
-        // that says so.
-        if (isStubNote(fm, body) || isGmNote(fm)) continue;
-
-        for (const hit of frontmatterWikilinks(fm)) {
-            fmLinkFindings.push({ file, ...hit });
-        }
-
-        const name = fm.name?.full ?? path.basename(file, ".md");
-        // The page's address, and therefore its URL. `name` is the
-        // display string and nothing else: it titles the page and labels an
-        // inbound link, and moving it moves no address.
-        let slug;
-        try {
-            slug = addressSlug(fm);
-        } catch (err) {
-            addressFindings.push({ file, reason: err.message });
-            continue;
-        }
-
-        const base = path.basename(file);
-        const rel = path.relative(contentBase, file);
-        pages.push({
-            kind: "content",
-            fm,
-            // The note's own path on disk. Carried so a link finding can be
-            // reported as `file:line:column:` against the source an author
-            // edits, rather than against the page this build emits.
+        const made = contentPage(note, {
+            ...ctx,
             file,
-            // The page's package, recorded once here so every consumer — the
-            // index's canonical keys, the table universe, the local-package set
-            // — reads one configured value and never frontmatter.
-            pkg,
-            body,
-            bodyLine,
-            name,
-            slug,
-            base,
-            // Top-level content directory ("Rules", "Skills", …). Wikilinks do
-            // not use it: a note is addressed as `type/shortcode` wherever it
-            // is filed.
-            tld: rel.split(path.sep)[0],
-            // Location below the content root, POSIX-separated.
-            relPath: rel.split(path.sep).join("/"),
-            // The immediate source subfolder — the page's `kbfolder`.
+            fileBase: path.basename(file),
+            relPath: path.relative(contentBase, file).split(path.sep).join("/"),
             folder: path.basename(path.dirname(file)),
-            // Every page is addressed by `(type, shortcode)` at the package
-            // root, which takes no content mount.
-            //
-            // A note `site.sections` names is the page of its section, and is
-            // published at the section rather than at its own address.
-            url:
-                ctx.sectionPages?.has(slug) ?
-                    `${ctx.base}${ctx.sectionPages.get(slug)}/`
-                :   `${ctx.base}${slug}/`,
+            present,
+            dates,
         });
+        if (!made) continue;
+        fmLinkFindings.push(...made.fmLinks);
+        if (made.addressFinding) addressFindings.push(made.addressFinding);
+        else pages.push(made.page);
     }
     return { pages, addressFindings, fmLinkFindings };
 }
@@ -574,281 +485,6 @@ export function tableUniverse(pages) {
     return byPackage;
 }
 
-/**
- * The frontmatter a page publishes with.
- *
- * A content page carries the package the build **derived**. No note
- * declares one, so the note's frontmatter alone would publish a page that does
- * not say which package it belongs to. Writing the derived value keeps a page
- * self-describing and makes sweeping the field out of a content tree
- * output-preserving for a site as it already is for the packs.
- *
- * **`related` is derived, never authored.** What links to a page is a fact
- * about every other page, known only once the whole tree has resolved — see
- * {@link module:engine/related-pages} — so an authored value is dropped, and
- * {@link renderPages} sets the derived block once it holds the graph.
- *
- * @param {object} page - The page.
- * @param {object} options
- * @param {(data: object, page: object) => void} [options.decorate] - Called
- *   with each page's frontmatter, for whatever a consumer's own pass adds.
- * @param {(value: unknown, type: string, accepts?: Iterable<string>) => string|null} [options.artSrc] -
- *   Translates an art address into the pathname the website resolver takes, or
- *   `null` where nothing answers it.
- * @param {(src: string) => string} [options.webSrc] - Translates an authored
- *   pathname into the address the website serves. Every artwork field goes
- *   through it, so a page's `img:` and its body images name the same file the
- *   same way.
- * @returns {object} The frontmatter.
- */
-export function pageFrontmatter(page, { decorate, webSrc, artSrc }) {
-    const { fm, slug } = page;
-    const data = {
-        ...fm,
-        ...(isPlainObject(fm.data) ? { data: { ...fm.data } } : {}),
-        // Spread after the note's own frontmatter. Guarded because
-        // `package: undefined` is not a value YAML can carry.
-        ...(page.pkg ? { package: page.pkg } : {}),
-        // The address, stated site-root relative; `slug` is its last segment.
-        slug,
-        url: `/${slug}/`,
-        title: pageTitle(page),
-        kbfolder: page.folder,
-    };
-    if (decorate) decorate(data, page);
-    delete data.related;
-    if (webSrc && artSrc) resolveArtFields(data, webSrc, artSrc);
-    return data;
-}
-
-/**
- * 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
- * shows.
- *
- * @param {object} page - The page, from {@link collectContentPages}.
- * @returns {string} The title.
- */
-function pageTitle(page) {
-    return page.name;
-}
-
-/**
- * Rewrite a page's artwork addresses into the URLs the website serves.
- *
- * The slots are read from {@link module:engine/art-fields.ART_SLOTS}, so a slot
- * added to the vocabulary reaches the page without anyone remembering this
- * function exists. Only an authored **string** is touched: `null` is a note
- * naming no art and `""` is one naming none on purpose, and neither is an
- * address to resolve. A slot's declining word (`banner: none`) is emitted as
- * a blank, the value a theme reads as "draw no image".
- *
- * **An address nothing answers is dropped**, not emitted as written. The theme
- * renders nothing where a value is absent — its silent-disappear convention —
- * and a raw address left in place would reach the reader as a broken image
- * source with nothing saying why.
- *
- * @param {object} data - The frontmatter being emitted, rewritten in place.
- * @param {(src: string) => string} webSrc - The website's pathname resolver.
- * @param {(value: unknown, type: string, accepts?: Iterable<string>) => string|null} artSrc -
- *   The address resolver, yielding the pathname `webSrc` takes.
- * @returns {void}
- */
-function resolveArtFields(data, webSrc, artSrc) {
-    for (const { key, type, accepts, declines } of ART_SLOTS) {
-        const holder = isPlainObject(data.data) ? data.data : null;
-        if (!holder) continue;
-        const value = holder[key];
-        if (declines !== undefined && value === declines) {
-            holder[key] = "";
-            continue;
-        }
-        if ((typeof value !== "string" && !isAddressTuple(value)) || value === "") continue;
-        const pathname = artSrc(value, type, accepts);
-        if (pathname === null) delete holder[key];
-        else holder[key] = webSrc(pathname);
-    }
-}
-
-/**
- * @param {unknown} value - Anything.
- * @returns {boolean} Whether it is a mapping a field may be read out of.
- */
-function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** Transform one content page. */
-export function renderSitePage(
-    page,
-    {
-        index,
-        foreign,
-        pass = {},
-        decorate,
-        sqlTables,
-        config,
-        artIndex,
-        figuresByAddress = new Map(),
-        events,
-        drawings = new Map(),
-        runs = runContext(config, undefined, {
-            referenceName: (target) => resolveInfoboxRef(index, target)?.name,
-        }),
-    },
-) {
-    const secretErrors = [];
-    const captionErrors = [];
-    const headingErrors = [];
-    const footnoteErrors = [];
-    const imageErrors = [];
-    const embedErrors = [];
-    const src = page.relPath ?? page.base;
-
-    const seenImages = new Map();
-    const webSrc = (src) => {
-        const occurrence = (seenImages.get(src) ?? 0) + 1;
-        seenImages.set(src, occurrence);
-        const problem = pathnameProblem(src);
-        if (problem) {
-            imageErrors.push({ file: page.file, src, occurrence, message: problem });
-            return src;
-        }
-        const forms = resolvePathname(src, config);
-        if (!forms || forms.web !== null) return forms?.web ?? src;
-        imageErrors.push({
-            file: page.file,
-            src,
-            occurrence,
-            message:
-                `\`${src}\` names a file the \`${forms.package}\` package ships, and ` +
-                "no asset host is configured to serve it from — set `site.assets` in " +
-                "package-build.config.yaml. Emitted as authored, the address resolves " +
-                "against the page's own URL, which is nowhere",
-        });
-        return src;
-    };
-    const artSrc = (value, type, accepts) => artPathname(artIndex, value, type, accepts).pathname;
-    // The role lookup a captioned item's `map` counter reaches through — see
-    // `engine/content-figures.mjs`'s `resolveRole`. It numbers the page's
-    // figures once, in expansion, and the render below reads that numbering.
-    const resolveRole = (address) => embedRole(artIndex, address);
-    // 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;
-    };
-    // 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);
-        });
-
-    // The frontmatter's art resolves before the body's pictures, so a picture
-    // named in both is counted in that order.
-    const data = pageFrontmatter(page, { decorate, webSrc, artSrc });
-    const expanded = expandContent(page.body, {
-        target: "web",
-        index,
-        note: { fm: page.fm, file: page.file, source: src, bodyLine: page.bodyLine },
-        prepared: {
-            sqlTables: sqlTables?.get(page.file),
-            pageLists: sqlTables?.pageLists?.get(page.file),
-            inline: sqlTables?.inline?.get(page.file),
-        },
-        events,
-        resolveRole,
-        figuresByAddress,
-        links: {
-            foreign: foreign.index,
-            assets: artIndex,
-            beforeLinks: pass.beforeLinks ? (text) => pass.beforeLinks(text, page) : undefined,
-            afterLinks: (text) => renderImageFigures(inlineDrawings(text), webSrc, lookupAsset),
-        },
-    });
-    const { lineMap } = expanded;
-    const tableErrors = expanded.findings.tables;
-    const expressionErrors = expanded.findings.expressions;
-    const wikiErrors = expanded.findings.links;
-    // The author's text and the sections the build generated after it are
-    // told apart by a comment, so the site writer can leave the generated
-    // links out of what makes a page reachable.
-    const resolvedBody =
-        expanded.generated ?
-            `${expanded.authored}\n\n${GENERATED_MARK}\n\n${expanded.generated}`
-        :   expanded.markdown;
-    for (const error of expanded.findings.captions)
-        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 [
-        ...scanBlocks(page.body).errors,
-        ...scanAlerts(page.body).errors,
-        ...scanPageBreaks(page.body).errors,
-        ...scanSpans(page.body).errors,
-        ...scanRuns(page.body, runs).errors,
-        ...markupAnchorFindings(page.body),
-    ])
-        secretErrors.push({
-            file: error.file ?? page.file,
-            line: error.file ? error.line : (page.bodyLine ?? 1) + error.line - 1,
-            column: error.column,
-            message: error.message,
-        });
-    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: error.file ?? page.file,
-            line: error.file ? error.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,
-        // The expanded body and its numbered figures, for the renderer that
-        // writes the whole page.
-        markdown: resolvedBody,
-        figures: expanded.figures.figures,
-        data,
-        // 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.
-        resolved: expanded.resolved.slice(0, expanded.authoredLinks),
-        tableErrors,
-        expressionErrors,
-        secretErrors,
-        captionErrors,
-        headingErrors,
-        footnoteErrors,
-        wikiErrors,
-        imageErrors,
-        embedErrors,
-    };
-}
-
 /**
  * Renders every page.
  *
@@ -1004,7 +640,10 @@ export function renderPages(pages, options) {
             artIndex,
             figuresByAddress,
             events,
-            drawings: maps,
+            drawing: (name) => {
+                const drawn = maps.get(name);
+                return drawn ? fs.readFileSync(drawn.file, "utf8") : undefined;
+            },
             runs,
         });
     const externalRunFindings = new Set();
@@ -1081,59 +720,6 @@ export function renderPages(pages, options) {
     };
 }
 
-/**
- * The named pass bundles a configuration may select.
- *
- * `site.pass` is the one part of the site contract that is *code* — a
- * repository's own body rewrites — so a configuration names a bundle instead of
- * supplying one, exactly as `itemBuilders` names an item registry. Required
- * lazily, so importing this module does not drag a package-specific half of the
- * toolchain in behind it.
- *
- * @type {Readonly<Record<string, () => Function>>}
- */
-const SITE_PASSES = Object.freeze({
-    sohlKb: () => require("../sohl/kb-passes.mjs").sohlKbPass,
-});
-
-/**
- * Resolves `site.pass` to its bundle.
- *
- * @param {string|undefined} name - The configured name.
- * @param {object} options - The configured options, plus `repoRoot`.
- * @returns {{beforeLinks?: Function}} The bundle.
- */
-export function resolveSitePass(name, options) {
-    if (!name) return {};
-    const factory = SITE_PASSES[name];
-    if (!factory) {
-        throw new Error(
-            `unknown site pass ${JSON.stringify(name)} — expected one of ` +
-                `${Object.keys(SITE_PASSES).join(", ")}`,
-        );
-    }
-    return factory()(options);
-}
-
-/** The site frontmatter decoration shared by the site writer and page preview. */
-export function sitePageDecorator(config, index) {
-    const router = routerFor(config);
-    return (data, page) => {
-        // 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),
-            router,
-            dates: index.dateContext,
-            contentPackage: index.contentPackage,
-        });
-    };
-}
-
 /**
  * Collects, checks and renders a content tree's pages, and reports what it found.
  *