@heroiclands/package-build 22.14.4 → 22.15.1

package/engine/note-vocabulary.mjs

@@ -97,8 +97,9 @@ import {
 // question, asked the way `checkPlace` and `checkCalendarNote` are.
 import { checkBeingAge } from "./being-age.mjs";
 import { checkSocialTies } from "./social-ties.mjs";
-import { SOCIAL_TIES } from "./social-tie-terms.mjs";
+import { SOCIAL_TIES, SOCIAL_TIE_TARGET_TYPES } from "./social-tie-terms.mjs";
 import { parseNoteDate } from "./note-dates.mjs";
+import { reckoningContext } from "./reckoning-markers.mjs";
 import { checkHeld } from "./holdings.mjs";
 import { checkCitedPopulations, checkPopulation } from "./populations.mjs";
 // What trade a settlement supports — the scale and the check that holds a
@@ -371,8 +372,9 @@ function checkPlace(note, opts) {
 
 /** Validate a being's authored date using the shared note-date grammar. */
 function checkBeingDate(key) {
-    return (note) =>
+    return (note, { index } = {}) =>
         parseNoteDate(note.fm?.data?.[key], {
+            ...reckoningContext(index),
             field: `data.${key}`,
             file: note.file,
             raw: note.raw,
@@ -719,7 +721,7 @@ export const NOTE_VOCABULARY = Object.freeze({
                 name: "socialTies",
                 kind: "map",
                 keyKind: "address",
-                accepts: ["being", "affiliation"],
+                accepts: SOCIAL_TIE_TARGET_TYPES,
                 terms: SOCIAL_TIES,
                 shape: "a map keyed by Address",
                 check: checkSocialTies,
@@ -1412,10 +1414,19 @@ export const NOTE_VOCABULARY = Object.freeze({
 
     map: Object.freeze({
         stubbable: true,
-        // One type, three subTypes: they differ only in the canvas defaults
-        // derived for them, which is precisely what a subType decides.
-        subTypes: Object.freeze(["battlemap", "localmap", "regionalmap"]),
+        // The subType classifies the map; `data.scene` carries its canvas.
+        subTypes: Object.freeze(["battlemap", "localmap", "regionalmap", "totm"]),
         data: Object.freeze([
+            {
+                name: "scene",
+                ...ANY,
+                describe: "A Foundry Scene export with all its authored fields.",
+            },
+            {
+                name: "fixup",
+                ...LIST,
+                describe: "Asset address replacements in an exported Scene.",
+            },
             // A Scene has no `img`, so the shared art key reaches nothing here:
             // a map's background is its own slot, and an `image` address.
             {
@@ -1425,6 +1436,11 @@ export const NOTE_VOCABULARY = Object.freeze({
                 accepts: ART_SLOTS.find((slot) => slot.key === "bgImage").accepts,
                 describe: "The map's background art — an `image` address.",
             },
+            {
+                name: "scale",
+                ...ANY,
+                describe: "Regional map distance per grid unit: {distance, unit}.",
+            },
             {
                 name: "dimensions",
                 ...LIST,

package/engine/pdf-build.mjs

@@ -100,7 +100,7 @@ import { collectContentPages, siteGates, tableUniverse, gatesFailed } from "./si
 import { resolveInfoboxRef, wikiContext } from "./site-index.mjs";
 import { resolveWebWikilinks } from "./web-wikilinks.mjs";
 import { linkFindingMessage } from "./wikilink-syntax.mjs";
-import { assetAddressIndex } from "./art-fields.mjs";
+import { artPathname, assetAddressIndex } from "./art-fields.mjs";
 import { expandContentTables } from "./content-tables.mjs";
 import { renderSecretBlocks } from "./content-secrets.mjs";
 import { protectCode } from "./code-fences.mjs";
@@ -118,6 +118,8 @@ import { isDraftNote } from "./note-vocabulary.mjs";
 import { infoboxTypstPreamble, infoboxesToTypst, linkToTypst } from "./infobox-render.mjs";
 import { noteInfoboxes } from "./infobox-registry.mjs";
 import { resolveIconGlyphs } from "./pdf-fonts.mjs";
+import { buildMaps, relatedPlaces } from "./map-build.mjs";
+import { mapWorld } from "./map-places.mjs";
 
 /**
  * The file on disk an authored image pathname names, or `null`.
@@ -637,6 +639,59 @@ export async function buildPdf({ config, out, version = "", compile = true } = {
 
     const banners = stageBanners(plan.entries, resolved, outDir, findings);
 
+    /** @type {Map<string, {path: string, title: string}>} Entry anchor → map page. */
+    const maps = new Map();
+    const world = mapWorld({
+        records,
+        foreignIndex: gates.foreign.index,
+        contentBase,
+        config: resolved,
+    });
+    const related = new Set(relatedPlaces(world.places));
+    const mapDir = path.join(outDir, "maps");
+    fs.rmSync(mapDir, { recursive: true, force: true });
+    const mappedEntries = plan.entries.filter(
+        (entry) =>
+            entry.kind === "note" &&
+            entry.record?.type === "place" &&
+            related.has(String(entry.record.shortcode ?? "").toLowerCase()),
+    );
+    if (mappedEntries.length) {
+        const centres = [...new Set(mappedEntries.map((entry) => entry.record.shortcode))];
+        const drawn = buildMaps({ world, outDir: mapDir, from: centres });
+        findings.push(...drawn.findings);
+        for (const entry of mappedEntries) {
+            maps.set(entry.anchor, {
+                path: `maps/from-${entry.record.shortcode}.svg`,
+                title: `From here: ${entry.record.name?.full ?? entry.record.shortcode}`,
+            });
+        }
+    }
+    for (const entry of plan.entries) {
+        if (entry.kind !== "note" || entry.record?.type !== "map") continue;
+        if (entry.record.subType !== "regionalmap") continue;
+        const image = entry.record.data?.bgImage;
+        if (!image) continue;
+        const found = artPathname(assets, image, "image", ["image", "icon"]);
+        if (!found.pathname) {
+            findings.push({
+                file: noteFile(contentBase, entry.record),
+                severity: "warning",
+                message: `the regional map's background "${image}" cannot be resolved for the book`,
+            });
+            continue;
+        }
+        const staged = stagedImagePath(found.pathname, resolved);
+        if (!staged || !staged.from.toLowerCase().endsWith(".svg")) continue;
+        const target = path.join(outDir, staged.to);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.copyFileSync(staged.from, target);
+        maps.set(entry.anchor, {
+            path: staged.to,
+            title: entry.record.name?.full ?? entry.record.shortcode,
+        });
+    }
+
     const assembled = renderBook({
         plan,
         bodies,
@@ -647,6 +702,7 @@ export async function buildPdf({ config, out, version = "", compile = true } = {
         version,
         preamble: infoboxTypstPreamble(),
         banners,
+        maps,
     });
     // Last, over the whole document: a reference can only be checked once every
     // declaration is in one string, and Typst treats a dangling one as fatal.

package/engine/pdf-render.mjs

@@ -963,6 +963,14 @@ export function bookTypstPreamble() {
             '    place(top, float: true, scope: "parent", clearance: 0.7em)[#body]\n' +
             "  }\n" +
             "}",
+        "#let book-place-map(title, path) = {\n" +
+            "  page(columns: 1)[\n" +
+            "    #set par(justify: false, first-line-indent: 0em)\n" +
+            '    #text(size: 18pt, weight: "bold", fill: book-head)[#title]\n' +
+            "    #v(0.4cm)\n" +
+            '    #image(path, width: 100%, height: book-text-height - 2cm, fit: "contain")\n' +
+            "  ]\n" +
+            "}",
         // Wide content spans the page, and how it spans depends on how tall it
         // is: a float is unbreakable and silently overflows, so anything taller
         // than a page takes pages of its own instead.
@@ -1077,6 +1085,8 @@ export function bookTypstPreamble() {
  *   declared it → the staged file's path, relative to the `.typ`. A declared
  *   banner this map does not carry has no file the compiler can open, so the
  *   plate draws without a picture.
+ * @param {Map<string, {path: string, title: string}>} [opts.maps] - An entry
+ *   anchor to its SVG path and page heading. Each map takes a page after its entry.
  * @returns {string} A complete `.typ` document.
  */
 export function renderBook({
@@ -1089,6 +1099,7 @@ export function renderBook({
     version = "",
     preamble = "",
     banners = new Map(),
+    maps = new Map(),
 } = {}) {
     // The two halves of one superfamily, chosen together: matched metrics are
     // most of why the sans can carry every heading over a serif body without
@@ -1236,6 +1247,13 @@ export function renderBook({
             out.push(body);
             out.push("");
         }
+        const map = maps.get(entry.anchor);
+        if (map) {
+            out.push(
+                `#book-place-map([${escapeTypst(map.title)}], "${escapeTypstString(map.path)}")`,
+            );
+            out.push("");
+        }
     }
 
     return `${out.join("\n")}\n`;

package/engine/reckoning-markers.mjs

@@ -0,0 +1,207 @@
+/*
+ * 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.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+import { canonicalDayOffset, daysInMonth } from "./calendars.mjs";
+import { parseNoteDate } from "./note-dates.mjs";
+
+/**
+ * Resolve every declared reckoning marker against its calendar and era start.
+ * The marker names one era, while the calendar supplies the month layout.
+ *
+ * @param {{notes?: readonly object[]}} index - The corpus link index.
+ * @param {number} daysPerYear - The world's year length.
+ * @returns {{markers: Map<string, object>, findings: object[]}} Resolved markers and errors.
+ */
+export function resolveReckoningMarkers(index, daysPerYear) {
+    const declared = new Map();
+    const markers = new Map();
+    const findings = [];
+
+    for (const note of index?.notes ?? []) {
+        const fm = note?.fm ?? note?.frontmatter ?? note;
+        if (fm?.type !== "lore" || fm?.subType !== "calendar") continue;
+        const eras = fm.data?.eras;
+        if (!Array.isArray(eras)) continue;
+        eras.forEach((row, position) => {
+            if (row?.marker === undefined) return;
+            const marker = row.marker;
+            const at = {
+                ...(note.file === undefined ? {} : { file: note.file }),
+                ...(note.raw === undefined ?
+                    {}
+                :   positionOfFrontmatterPath(note.raw, ["data", "eras", position, "marker"])),
+            };
+            if (typeof marker !== "string" || !/^[A-Z][A-Z0-9]*$/.test(marker)) {
+                findings.push({
+                    ...at,
+                    severity: "error",
+                    message:
+                        "an era marker is uppercase letters and digits, starting with a letter",
+                });
+                return;
+            }
+            if (declared.has(marker)) {
+                findings.push({
+                    ...at,
+                    severity: "error",
+                    message: `reckoning marker ${marker} is declared more than once`,
+                });
+                return;
+            }
+            declared.set(marker, {
+                marker,
+                era: `${fm.shortcode}.${row.shortcode}`,
+                calendar: fm.data,
+                start: row.start,
+                end: row.end,
+                note,
+                position,
+            });
+        });
+    }
+
+    const visiting = new Set();
+    const failed = new Set();
+    function resolve(marker) {
+        if (markers.has(marker)) return markers.get(marker);
+        if (failed.has(marker)) return null;
+        const row = declared.get(marker);
+        if (!row) return null;
+        if (visiting.has(marker)) {
+            findings.push({
+                ...(row.note.file === undefined ? {} : { file: row.note.file }),
+                severity: "error",
+                message: `reckoning marker cycle includes ${[...visiting, marker].join(" → ")}`,
+            });
+            failed.add(marker);
+            return null;
+        }
+        visiting.add(marker);
+        if (row.start === undefined || row.start === null) {
+            findings.push({
+                ...(row.note.file === undefined ? {} : { file: row.note.file }),
+                severity: "error",
+                message: `reckoning marker ${marker} needs an era start`,
+            });
+            failed.add(marker);
+        }
+        const dependency =
+            typeof row.start === "string" ? /^([A-Z][A-Z0-9]*)\(/.exec(row.start)?.[1] : null;
+        if (dependency && !failed.has(marker)) resolve(dependency);
+        if (!failed.has(marker)) {
+            const parsed = parseNoteDate(row.start, {
+                markers,
+                daysPerYear,
+                field: "data.eras.start",
+                allowUnknown: false,
+                file: row.note.file,
+                raw: row.note.raw,
+                keyPath: ["data", "eras", row.position, "start"],
+            });
+            findings.push(...parsed.findings);
+            if (
+                parsed.date?.known &&
+                Number.isSafeInteger(parsed.date.canonicalYear) &&
+                parsed.findings.every((f) => f.severity !== "error")
+            ) {
+                const entry = {
+                    era: row.era,
+                    calendar: row.calendar,
+                    epochYear: parsed.date.canonicalYear,
+                    epochDay: parsed.date.canonicalDay ?? 1,
+                };
+                markers.set(marker, entry);
+            } else {
+                if (parsed.date && parsed.findings.length === 0)
+                    findings.push({
+                        ...(row.note.file === undefined ? {} : { file: row.note.file }),
+                        severity: "error",
+                        message: `reckoning marker ${marker} needs a canonically resolved era start`,
+                    });
+                failed.add(marker);
+            }
+        }
+        visiting.delete(marker);
+        return markers.get(marker) ?? null;
+    }
+    for (const marker of declared.keys()) resolve(marker);
+    for (const [marker, row] of declared) {
+        const entry = markers.get(marker);
+        if (!entry || row.end === undefined || row.end === null) continue;
+        const parsed = parseNoteDate(row.end, {
+            markers,
+            daysPerYear,
+            field: "data.eras.end",
+            allowUnknown: false,
+            file: row.note.file,
+            raw: row.note.raw,
+            keyPath: ["data", "eras", row.position, "end"],
+        });
+        findings.push(...parsed.findings);
+        if (!Number.isSafeInteger(parsed.date?.canonicalYear)) {
+            if (parsed.date && parsed.findings.length === 0)
+                findings.push({
+                    ...(row.note.file === undefined ? {} : { file: row.note.file }),
+                    severity: "error",
+                    message: `reckoning marker ${marker} needs a canonically resolved era end`,
+                });
+            continue;
+        }
+        const firstEndDay = canonicalDayOffset(
+            parsed.date.canonicalYear,
+            parsed.date.canonicalDay ?? 1,
+            1,
+            daysPerYear,
+        );
+        const extraDays =
+            parsed.date.precision === "year" ? daysPerYear - 1
+            : parsed.date.precision === "month" ?
+                (daysInMonth(markers.get(parsed.date.marker)?.calendar, parsed.date.month) ?? 1) - 1
+            :   0;
+        const endOffset = firstEndDay + extraDays;
+        const startOffset = canonicalDayOffset(entry.epochYear, entry.epochDay, 1, daysPerYear);
+        if (endOffset < startOffset) {
+            findings.push({
+                ...(row.note.file === undefined ? {} : { file: row.note.file }),
+                severity: "error",
+                message: `reckoning marker ${marker} ends before its era starts`,
+            });
+            continue;
+        }
+        entry.endOffset = endOffset;
+    }
+    return { markers, findings };
+}
+
+/** One resolved date context per corpus index, shared by its note checks. */
+const contexts = new WeakMap();
+
+/**
+ * Read the world's year length and its era markers from one corpus index.
+ *
+ * @param {{notes?: readonly object[]}|undefined} index - The corpus index.
+ * @returns {{markers: Map<string, object>, daysPerYear: number|undefined, findings: object[]}}
+ */
+export function reckoningContext(index) {
+    if (!index || typeof index !== "object")
+        return { markers: new Map(), daysPerYear: undefined, findings: [] };
+    const cached = contexts.get(index);
+    if (cached) return cached;
+    const world = (index.notes ?? []).find((note) => {
+        const fm = note?.fm ?? note?.frontmatter ?? note;
+        return fm?.type === "place" && fm?.data?.year?.days;
+    });
+    const fm = world?.fm ?? world?.frontmatter ?? world;
+    const daysPerYear = fm?.data?.year?.days;
+    const context = { ...resolveReckoningMarkers(index, daysPerYear), daysPerYear };
+    contexts.set(index, context);
+    return context;
+}

package/engine/scenes.mjs

@@ -57,6 +57,7 @@ import {
     slugify,
     defaultStats,
     folderField,
+    resolveImg,
 } from "./helpers.mjs";
 import { BasePackCompiler } from "./base-compiler.mjs";
 // What an Adventure member may carry is one rule, and the module that owns the
@@ -72,6 +73,11 @@ import { packRouter } from "./pack-router.mjs";
 import { foundryPackageId } from "./content-package.mjs";
 import { itemDocEntryId } from "./item-docs.mjs";
 import { behaviorDocId, buildScene, isMapType, regionDocId } from "./map-notes.mjs";
+import { buildItineraryScenes } from "./itinerary-scenes.mjs";
+import { emitDiagnostic } from "./diagnostics.mjs";
+import { rasterizeMapSvg } from "./map-raster.mjs";
+import { artPathname, artSlot } from "./art-fields.mjs";
+import { buildExportedScene } from "./exported-scene.mjs";
 
 /**
  * Every SoHL action name this build knows about, for the `action:` warning on a
@@ -127,6 +133,7 @@ export function collectKnownActionNames(repoRoot) {
 export class Scenes extends BasePackCompiler {
     static id = "scenes";
     static label = "map";
+    static readsPackOutputOf = Object.freeze(["JournalEntry"]);
 
     /**
      * A map note's `bgImage` is its background art, and it is **required**: the
@@ -157,8 +164,12 @@ export class Scenes extends BasePackCompiler {
         companionDests = {},
         folderResolver = () => null,
         repoRoot = process.cwd(),
+        config,
+        packName,
+        bundleSourceDirs = {},
+        corpus,
     }) {
-        super({ contentBase, assetsBase, dest, folderResolver, skipDirectories });
+        super({ contentBase, assetsBase, dest, folderResolver, skipDirectories, packName, corpus });
         if (!companionDests.adventures) {
             throw new Error("Scenes compiler requires an `adventures` companion destination");
         }
@@ -170,6 +181,9 @@ export class Scenes extends BasePackCompiler {
             value: repoRoot,
             writable: false,
         });
+        this.mapConfig = config;
+        this.packName = packName;
+        this.journalSourceDirs = bundleSourceDirs.JournalEntry ?? [];
     }
 
     /**
@@ -424,28 +438,73 @@ export class Scenes extends BasePackCompiler {
         const { value: authoredFolder } = folderField(fm);
         const folder = this.folderResolver(authoredFolder, { isAddress: true });
         const warnings = [];
-        const scene = buildScene(fm, {
-            packageId: foundryPackageId(),
-            // The art resolver, so the map pass turns an address into the path
-            // each surface serves without holding an index of its own. `accepts`
-            // is threaded through so `bgImage`, one of the four declared art
-            // slots, is held to its own accepted set here exactly as it is
-            // through `artPath`.
-            art: (value, key, type, accepts) => this.artPathOf(value, key, type, accepts),
-            name,
-            folder,
-            stats: this.stats,
-            journalEntryId: entryId,
-            // A map note's prose is a derived JournalEntry: it lands in the
-            // default JournalEntry pack, not in whichever Scene pack the map
-            // itself was routed to.
-            // This compile's router, as everywhere else in this pass.
-            journalPack: this.#packRouter.defaultOf("JournalEntry"),
-            pageIds: hasBody ? this.#pageIds(markdown, entryId, name) : new Map(),
-            knownActions: this.knownActions,
-            warnings,
-            ...this.#resolvers(this.index, this.effectsByAddress, fm.shortcode),
-        });
+        if (fm.data?.scene && fm.subType === "regionalmap") {
+            throw new Error("`data.scene` is for battlemap and localmap notes");
+        }
+        if (fm.data?.fixup !== undefined && !fm.data?.scene) {
+            throw new Error("`data.fixup` needs an exported Scene at `data.scene`");
+        }
+        const bgImage =
+            fm.data?.scene ?
+                null
+            :   this.artPathOf(fm.data?.bgImage, "bgImage", "image", artSlot("bgImage")?.accepts);
+        if (
+            bgImage?.toLowerCase().endsWith(".svg") &&
+            (!["regionalmap", "totm"].includes(fm.subType) ||
+                (fm.subType === "regionalmap" && !fm.data?.scale))
+        ) {
+            throw new Error("an SVG map needs `subType: regionalmap` and `data.scale`");
+        }
+        const raster =
+            bgImage?.toLowerCase().endsWith(".svg") ?
+                rasterizeMapSvg({
+                    foundryPath: bgImage,
+                    width: fm.sohl?.dimensions?.[0],
+                    height: fm.sohl?.dimensions?.[1],
+                    sceneId: fm.id,
+                    config: this.mapConfig,
+                })
+            :   null;
+        const scene =
+            fm.data?.scene ?
+                buildExportedScene(fm, markdown, {
+                    journalEntryId: entryId,
+                    stats: this.stats,
+                    resolveAddress: (address) => {
+                        const result = artPathname(this.linkIndex, address, "image");
+                        if (!result.resolved || !result.pathname) {
+                            throw new Error(
+                                `Scene fixup address "${address}" cannot resolve to an asset: ${result.reason ?? "no pathname"}`,
+                            );
+                        }
+                        return resolveImg(result.pathname);
+                    },
+                })
+            :   buildScene(fm, {
+                    packageId: foundryPackageId(),
+                    // The art resolver, so the map pass turns an address into the path
+                    // each surface serves without holding an index of its own. `accepts`
+                    // is threaded through so `bgImage`, one of the four declared art
+                    // slots, is held to its own accepted set here exactly as it is
+                    // through `artPath`.
+                    art: (value, key, type, accepts) =>
+                        key === "bgImage" && raster ?
+                            raster
+                        :   this.artPathOf(value, key, type, accepts),
+                    name,
+                    folder,
+                    stats: this.stats,
+                    journalEntryId: entryId,
+                    // A map note's prose is a derived JournalEntry: it lands in the
+                    // default JournalEntry pack, not in whichever Scene pack the map
+                    // itself was routed to.
+                    // This compile's router, as everywhere else in this pass.
+                    journalPack: this.#packRouter.defaultOf("JournalEntry"),
+                    pageIds: hasBody ? this.#pageIds(markdown, entryId, name) : new Map(),
+                    knownActions: this.knownActions,
+                    warnings,
+                    ...this.#resolvers(this.index, this.effectsByAddress, fm.shortcode),
+                });
         for (const message of warnings) {
             // Named by file, like every other note diagnostic. A map
             // warning is about the note's frontmatter, which carries no
@@ -479,7 +538,7 @@ export class Scenes extends BasePackCompiler {
             this.places.set(placeKey, {
                 key: placeKey,
                 name: sohlField(fm, "placeName", null) || name,
-                img: this.artPath(fm, "bgImage"),
+                img: fm.data?.scene ? null : this.artPath(fm, "bgImage"),
                 pinned: false,
                 scenes: [],
                 journal: [],
@@ -488,7 +547,7 @@ export class Scenes extends BasePackCompiler {
         const place = this.places.get(placeKey);
         place.scenes.push(stripAdventureKeys(scene));
         if (journal) place.journal.push(stripAdventureKeys(journal));
-        if (Object.keys(fm.sohl?.locations ?? {}).length) {
+        if (scene.notes?.length || Object.keys(fm.sohl?.locations ?? {}).length) {
             place.pinned = true;
         }
         return scene;
@@ -500,8 +559,36 @@ export class Scenes extends BasePackCompiler {
      *
      * @returns {Promise<void>}
      */
-    async finish() {
+    async finish(stats) {
         this.adventureCount = 0;
+        const firstScenePack = this.mapConfig?.packs.find((pack) => pack.type === "Scene")?.name;
+        if (this.mapConfig && this.packName === firstScenePack) {
+            const generated = buildItineraryScenes({
+                config: this.mapConfig,
+                records: this.corpus.records,
+                contentBase: this.contentBase,
+                journalSourceDirs: this.journalSourceDirs,
+                stats: this.stats,
+            });
+            for (const finding of generated.findings) emitDiagnostic(finding);
+            if (generated.scenes.length) {
+                const place = {
+                    key: "generated-itineraries",
+                    name: "Itinerary Maps",
+                    img: null,
+                    pinned: true,
+                    scenes: [],
+                    journal: generated.journal,
+                };
+                for (const scene of generated.scenes) {
+                    this.writeEntry(scene);
+                    place.scenes.push(stripAdventureKeys(scene));
+                }
+                this.places.set(place.key, place);
+                stats.compiled += generated.scenes.length;
+                this.compiledCount = stats.compiled;
+            }
+        }
         for (const place of this.places.values()) {
             // A scene that references nothing ships fine as a plain `scenes`
             // entry; only pins need the id-preserving import an Adventure gives.

package/engine/site-build.mjs

@@ -78,6 +78,7 @@ 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, presentAmongRecords } from "./being-age.mjs";
+import { reckoningContext } from "./reckoning-markers.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";
@@ -196,19 +197,20 @@ export function collectContentPages(contentBase, ctx) {
     // The package's declared present, read once from the same corpus the site
     // and the PDF share — see `engine/being-age.mjs`. `pdf-build.mjs` reaches
     // this through the pages this function returns, so one call covers both.
-    const present = presentAmongRecords(
+    const records =
         ctx.records ??
-            indexRecordsFor({
-                contentBase,
-                config: ctx.config,
-                skipDirectories: ctx.skipDirectories,
-            }),
-    );
+        indexRecordsFor({
+            contentBase,
+            config: ctx.config,
+            skipDirectories: ctx.skipDirectories,
+        });
+    const present = presentAmongRecords(records);
+    const dates = reckoningContext({ notes: records });
 
     for (const file of siteCorpusFiles(contentBase, ctx)) {
         const note = readNote(file, ctx);
         if (!note) continue;
-        applyComputedBeingAge(note.fm, present);
+        applyComputedBeingAge(note.fm, present, dates);
         const { fm, body, bodyLine } = note;
         // The configuration's, never a note's: `package:` is retired, so every
         // note in the tree belongs to the package this repository compiles.
@@ -987,15 +989,12 @@ export function sitePageDecorator(config, index) {
  *   {@link module:engine/sql-tables.prepareSqlTables}. A page authoring an
  *   `sql` directive with none prepared is a table error: nothing here runs a
  *   query.
- * @param {(engine: string) => string|undefined} [options.locate] - How a
- *   GraphViz engine's binary is found, for the maps; the real lookup by
- *   default.
  * @returns {{gates: object, stats: object|null, tableErrors: object[],
  *   wikiErrors: object[], imageErrors: object[], mapFindings: object[],
  *   manifests: object|null}} `mapFindings` is what drawing the maps found —
  *   warnings, never a reason to fail the build.
  */
-export function buildSite({ config, sqlTables, locate } = {}) {
+export function buildSite({ config, sqlTables } = {}) {
     const resolved = config ?? loadPackConfig();
     const site = resolved.site;
     const scheme = resolved.publish.address;
@@ -1179,7 +1178,6 @@ export function buildSite({ config, sqlTables, locate } = {}) {
                 foreignIndex: gates.foreign.index,
                 config: resolved,
                 base,
-                ...(locate ? { locate } : {}),
             })
         :   { maps: new Map(), findings: [] };