@heroiclands/package-build 23.12.5 → 23.12.7

package/engine/content-session.mjs

@@ -21,6 +21,7 @@ import * as sql from "./sql-tables.mjs";
 import { captureContentSources } from "./content-sources.mjs";
 import { buildLinkIndex } from "./content-links.mjs";
 import { buildContentLinkIndex } from "./helpers.mjs";
+import { runContext } from "./content-scripts.mjs";
 import { loadForeignIndexes } from "./metadata-index.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
 import { routerFor } from "./pack-router.mjs";
@@ -199,6 +200,7 @@ export async function createContentSession({
             return memo("compile", async () => {
                 const sqlTables = await session.sqlTables("all");
                 return {
+                    runs: runContext(config, records),
                     records,
                     parsed,
                     problems,

package/engine/data-keys.mjs

@@ -62,7 +62,7 @@ import { nearest } from "./near-miss.mjs";
  * @property {string} name - The key as an author writes it.
  * @property {string} [kind] - Its value's shape: `string`, `date`, `number`,
  *   `integer`, `boolean`, `address`, `list`, `map`, `scalar-or-map`,
- *   `string-or-list`, or `string-list-or-map` — see {@link fitsKind}. Absent, the check
+ *   `string-or-list`, `string-list-or-map` or `list-or-map` — see {@link fitsKind}. Absent, the check
  *   makes no claim about the value.
  * @property {readonly string[]} [allowed] - The closed set a present value is
  *   one of, where the key takes a fixed word.
@@ -156,6 +156,10 @@ export function fitsKind(value, kind) {
         // described by `values`.
         case "string-list-or-map":
             return fitsKind(value, "string-or-list") || fitsKind(value, "map");
+        // A list described by `entries`, or a map with the keys `fields` names:
+        // a mapping row is `[from, to]` or `{from, to, before?, at?}`.
+        case "list-or-map":
+            return Array.isArray(value) || fitsKind(value, "map");
         default:
             return true;
     }

package/engine/dictionary-layout.mjs

@@ -48,7 +48,7 @@
 
 import { parseAddress, readCanonicalKey, renderAddress, splitAnchor } from "./address.mjs";
 import { dictionaryEntryAnchor, dictionaryLetter } from "./dictionary-rows.mjs";
-import { VERB_PERSON_FIELDS } from "./language-terms.mjs";
+import { verbPattern } from "./verb-pattern.mjs";
 import {
     WORD_CLASS_BASES,
     WORD_CLASS_MODIFIERS,
@@ -191,16 +191,22 @@ function verbTables(rows, opts) {
         patterns.set(opts.pageLanguage ?? "", { verbs: opts.verbs });
     const tables = [];
     for (const [language, { verbs, label }] of [...patterns].sort(([a], [b]) => compare(a, b))) {
-        let endings;
-        if (verbs.invariant === true) endings = [["All persons", "unchanged"]];
-        else if (
-            VERB_PERSON_FIELDS.every((person) => typeof verbs.persons?.[person.name] === "string")
-        )
-            endings = VERB_PERSON_FIELDS.map((person) => [
-                person.label,
-                verbs.persons[person.name] ? `-${verbs.persons[person.name]}` : "unchanged",
-            ]);
-        else continue;
+        const pattern = verbPattern(verbs);
+        if (!pattern) continue;
+        const replaced = pattern.replaces === undefined ? undefined : `-${pattern.replaces}`;
+        const endings =
+            pattern.invariant ?
+                [["All persons", "unchanged"]]
+            :   pattern.endings.map(({ label, ending }) => [
+                    label,
+                    ending ? `-${ending}`
+                    : replaced ? `${replaced} dropped`
+                    : "unchanged",
+                ]);
+        const heading =
+            replaced && !pattern.invariant ?
+                `Ending in place of a closing ${replaced}`
+            :   "Ending added to citation form";
         const title =
             patterns.size > 1 ?
                 `**Verbs (${String(opts.labelOf?.(language) ?? label ?? language).replace(/[\r\n]+/g, " ")})**`
@@ -209,7 +215,7 @@ function verbTables(rows, opts) {
             [
                 title,
                 "",
-                "| Person | Ending added to citation form |",
+                `| Person | ${verbCell(heading)} |`,
                 "| --- | --- |",
                 ...endings.map((ending) => `| ${ending.map(verbCell).join(" | ")} |`),
             ].join("\n"),

package/engine/dictionary-rows.mjs

@@ -130,8 +130,17 @@ const isSingleWord = (title) => !/[\s\-‐‑]/u.test(title);
 /** Whether a glossary entry states a definition. */
 const defines = (entry) => typeof entry.definition === "string" && entry.definition.trim() !== "";
 
-/** A noun's stated plural, or the first literal ending replacement that fits. */
-function pluralOf(word, grammar) {
+/**
+ * A noun's stated plural, or the first literal ending replacement that fits.
+ *
+ * @param {{form: string, class?: unknown, plural?: unknown}} word - A word of
+ *   `data.words`.
+ * @param {Record<string, any>|undefined} grammar - Its language's
+ *   `data.grammar`.
+ * @returns {string|null} The plural, or `null` for a word that is no noun or
+ *   that no rule fits.
+ */
+export function pluralOf(word, grammar) {
     if (parseWordClass(word.class).base !== "n") return null;
     if (typeof word.plural === "string" && word.plural) return word.plural;
     for (const rule of Array.isArray(grammar?.plural) ? grammar.plural : []) {

package/engine/event-rows.mjs

@@ -25,10 +25,19 @@
  * `resolvedDates.events`, position for position with `data.events`, and the
  * sort keys are read from it rather than parsed again here.
  *
- * **`whenText` and `untilText` are the dates as a reader sees them**: printed
- * as the `dateformat` helper prints a date, in the calendar the owning note
- * names in `data.calendar`, else the one the world note names, else in the era
- * the date itself names. A date that does not resolve keeps its authored text.
+ * **`whenText` and `untilText` are the dates as a reader of the owning note
+ * sees them**: printed as the `dateformat` helper prints a date, in the
+ * calendar the owning note resolves to — see
+ * {@link module:engine/note-calendars} — else in the era the date itself
+ * names. A date that does not resolve keeps its authored text.
+ *
+ * **`whenIn` and `untilIn` are the same dates in every calendar**: a struct
+ * keyed by each calendar note's canonical Address, every calendar the corpus
+ * holds or any note resolves to, so a query reads a date in the calendar it
+ * chooses — `e.whenIn['thalorna-note-lore-commoncal']`. Every row carries every
+ * key; a date a calendar cannot print reads there as it would in `whenText`
+ * with no calendar, and an absent date is `NULL`. The event views select the
+ * key of the page's calendar.
  *
  * @module
  */
@@ -36,6 +45,7 @@
 import { ownDocumentSystem, renderAddress } from "./address.mjs";
 import { printEventDateIn } from "./event-fields.mjs";
 import { EVENT_ENTRY_KEYS } from "./note-event-terms.mjs";
+import { calendarAddress } from "./reckoning-markers.mjs";
 
 /** The columns a row carries besides the event's own keys, before them. */
 const IDENTITY_COLUMNS = Object.freeze(["note", "address"]);
@@ -46,12 +56,16 @@ export const EVENT_SORT_COLUMNS = Object.freeze(["whenSort", "whenYear", "untilS
 /** The printed dates a row carries, after the sort keys. */
 export const EVENT_TEXT_COLUMNS = Object.freeze(["whenText", "untilText"]);
 
+/** The dates a row carries in every calendar, after the printed ones. */
+export const EVENT_CALENDAR_COLUMNS = Object.freeze(["whenIn", "untilIn"]);
+
 /** Every column of the `events` relation, in order. */
 export const EVENT_COLUMNS = Object.freeze([
     ...IDENTITY_COLUMNS,
     ...EVENT_ENTRY_KEYS,
     ...EVENT_SORT_COLUMNS,
     ...EVENT_TEXT_COLUMNS,
+    ...EVENT_CALENDAR_COLUMNS,
 ]);
 
 /** The keys whose authored value is a date, printed as the text it was written as. */
@@ -95,18 +109,35 @@ function axisKeys(date) {
 }
 
 /**
- * The calendar the world note names, which displays every date whose own note
- * names none.
+ * Every calendar a set of records can print an event's date in: each calendar
+ * note's canonical Address, and every calendar a note resolves to.
  *
- * @param {Record<string, any>[]} records - Index records.
- * @returns {string|undefined} The calendar's Address or shortcode.
+ * @param {Iterable<Record<string, any>>} records - Index records, every
+ *   Address a string.
+ * @returns {string[]} The calendars, sorted.
  */
-function worldCalendar(records) {
+export function eventCalendars(records) {
+    const calendars = new Set();
     for (const record of records) {
-        if (record?.type === "place" && record.data?.year?.days && record.data.calendar)
-            return String(record.data.calendar);
+        const resolved = calendarAddress(record?.resolvedCalendar);
+        if (resolved) calendars.add(resolved);
+        if (
+            record?.type === "lore" &&
+            String(record.subType ?? "").toLowerCase() === "calendar" &&
+            record.package &&
+            record.shortcode &&
+            !record.documents
+        )
+            calendars.add(
+                renderAddress({
+                    package: String(record.package),
+                    system: "note",
+                    type: "lore",
+                    shortcode: String(record.shortcode),
+                }),
+            );
     }
-    return undefined;
+    return [...calendars].sort();
 }
 
 /**
@@ -115,12 +146,16 @@ function worldCalendar(records) {
  * @param {Iterable<Record<string, any>>} records - Index records, every
  *   Address a string, already narrowed to the audience being published to.
  * @param {object} [dates] - The reckoning context the dates are printed in.
+ * @param {readonly string[]} [calendars] - The calendars `whenIn` and
+ *   `untilIn` are keyed by: {@link eventCalendars} of every record of the
+ *   corpus, whatever the audience, so every surface's relation has the same
+ *   keys. Absent, those of `records`.
  * @returns {object[]} One row per event entry, in record then entry order.
  */
-export function eventRows(records, dates) {
+export function eventRows(records, dates, calendars) {
     const rows = [];
     const all = [...records];
-    const world = worldCalendar(all);
+    const keys = calendars ?? eventCalendars(all);
     for (const record of all) {
         const events = record?.data?.events;
         if (!Array.isArray(events) || !events.length) continue;
@@ -128,7 +163,7 @@ export function eventRows(records, dates) {
         if (!note) continue;
         const resolved =
             Array.isArray(record.resolvedDates?.events) ? record.resolvedDates.events : [];
-        const calendar = record.data?.calendar ? String(record.data.calendar) : world;
+        const calendar = calendarAddress(record.resolvedCalendar);
         events.forEach((entry, position) => {
             if (!entry || typeof entry !== "object" || Array.isArray(entry)) return;
             const row = {
@@ -149,10 +184,20 @@ export function eventRows(records, dates) {
             row.untilSort = until.sort;
             row.untilYear = until.year;
             for (const key of DATE_KEYS) {
+                const date = resolved[position]?.[key];
                 row[`${key}Text`] =
-                    row[key] === null ?
-                        null
-                    :   printEventDateIn(row[key], resolved[position]?.[key], dates, calendar);
+                    row[key] === null ? null : printEventDateIn(row[key], date, dates, calendar);
+                row[`${key}In`] =
+                    keys.length ?
+                        Object.fromEntries(
+                            keys.map((each) => [
+                                each,
+                                row[key] === null ?
+                                    null
+                                :   printEventDateIn(row[key], date, dates, each),
+                            ]),
+                        )
+                    :   null;
             }
             rows.push(row);
         });

package/engine/event-views.mjs

@@ -41,6 +41,7 @@
 
 import { ownDocumentSystem, renderAddress } from "./address.mjs";
 import { authoredSection, sectionHeading } from "./generated-sections.mjs";
+import { calendarAddress } from "./reckoning-markers.mjs";
 
 /** A literal SQL string. */
 const literal = (text) => `'${String(text).replace(/'/g, "''")}'`;
@@ -48,6 +49,16 @@ const literal = (text) => `'${String(text).replace(/'/g, "''")}'`;
 /** A list of SQL string literals, for an `IN (…)`. */
 const literals = (texts) => texts.map(literal).join(", ");
 
+/**
+ * The `When` column of a view on a page whose dates print in `calendar`: the
+ * event's date in that calendar, or — on a page with no calendar — in its
+ * owning note's.
+ *
+ * @param {string} [calendar] - The page's calendar, a canonical Address.
+ * @returns {string} The column's expression.
+ */
+const whenColumn = (calendar) => (calendar ? `e.whenIn[${literal(calendar)}]` : "e.whenText");
+
 /** The order every view sorts its rows in: by date, undated last. */
 const BY_DATE = "ORDER BY e.whenSort NULLS LAST, e.address";
 
@@ -65,7 +76,7 @@ const BY_DATE = "ORDER BY e.whenSort NULLS LAST, e.address";
  *
  * @type {ReadonlyArray<Readonly<{slug: string, heading: string,
  *   applies: (record: object) => boolean,
- *   query: (self: string[], shape: CorpusShape, columns?: {felt?: boolean}) => {fence: string, own?: string}|null,
+ *   query: (self: string[], shape: CorpusShape, columns?: {felt?: boolean, calendar?: string}) => {fence: string, own?: string}|null,
  *   owners?: (db: object, selves: string[][], shape: CorpusShape) => Promise<Set<string>>,
  *   felt?: (db: object, selves: string[][], shape: CorpusShape) => Promise<Set<string>>}>>}
  */
@@ -87,13 +98,13 @@ export const EVENT_VIEWS = Object.freeze([
             (record.type === "lore" && record.subType === "culture"),
         owners: (db, selves, shape) =>
             namedOwners(db, selves, "SELECT unnest(who).ref AS ref FROM events", shape.who),
-        query: (self, shape) => {
+        query: (self, shape, columns = {}) => {
             if (!shape.who) return null;
             const named = `list_filter(e.who, w -> w.ref IN (${literals(self)}))`;
             return {
                 fence: [
                     "SELECT e.note AS _ref,",
-                    '       e.whenText AS "When",',
+                    `       ${whenColumn(columns.calendar)} AS "When",`,
                     '       e.summary AS "What happened",',
                     `       array_to_string(list_transform(${named}, w -> w.role), ', ') AS "Role"`,
                     "FROM events e",
@@ -117,12 +128,12 @@ export const EVENT_VIEWS = Object.freeze([
                 'SELECT account."by" AS ref FROM (SELECT unnest(accounts) AS account FROM events)',
                 shape.accounts,
             ),
-        query: (self, shape) => {
+        query: (self, shape, columns = {}) => {
             if (!shape.accounts) return null;
             return {
                 fence: [
                     "SELECT e.note AS _ref,",
-                    '       e.whenText AS "When",',
+                    `       ${whenColumn(columns.calendar)} AS "When",`,
                     '       e.summary AS "Event",',
                     '       e.account.says AS "What they say",',
                     '       e.account.agrees AS "Agrees"',
@@ -145,7 +156,7 @@ export const EVENT_VIEWS = Object.freeze([
                     "FROM (SELECT unnest(follows) AS edge FROM events)",
                 shape.follows,
             ),
-        query: (self, shape) => {
+        query: (self, shape, columns = {}) => {
             if (!shape.follows) return null;
             const edges =
                 `list_filter(e.follows, f -> split_part(f.event, '#', 1) ` +
@@ -153,7 +164,7 @@ export const EVENT_VIEWS = Object.freeze([
             return {
                 fence: [
                     "SELECT e.note AS _ref,",
-                    '       e.whenText AS "When",',
+                    `       ${whenColumn(columns.calendar)} AS "When",`,
                     '       e.summary AS "What followed",',
                     `       array_to_string(list_transform(${edges}, f -> f.how), ', ') AS "How"`,
                     "FROM events e",
@@ -307,8 +318,9 @@ async function chronologyRoots(db, selves, shape, conditions) {
  *
  * @param {string[]} self - The place's Address, in each form.
  * @param {CorpusShape} shape - What the corpus states.
- * @param {{felt?: boolean}} [columns] - `felt: false` when no row of this
- *   place is felt there, which leaves the `Felt here` column out.
+ * @param {{felt?: boolean, calendar?: string}} [columns] - `felt: false` when
+ *   no row of this place is felt there, which leaves the `Felt here` column
+ *   out; `calendar`, the page's calendar, which the `When` column prints in.
  * @returns {{fence: string, own: string}|null} The query, and the one that
  *   counts the place's own rows.
  */
@@ -332,7 +344,7 @@ function chronologyQuery(self, shape, columns = {}) {
         ...below,
         "here AS (SELECT list(place) AS places FROM below)",
         "SELECT e.note AS _ref,",
-        '       e.whenText AS "When",',
+        `       ${whenColumn(columns.calendar)} AS "When",`,
         shape.reach && columns.felt !== false ?
             '       e.summary AS "What happened",'
         :   '       e.summary AS "What happened"',
@@ -453,11 +465,12 @@ export async function eventViewSections(db, records, fileOf, only) {
         const sections = new Map();
         for (const view of EVENT_VIEWS) {
             if (!view.applies(record) || authoredSection(record, view.slug)) continue;
-            const query = view.query(
-                self,
-                shape,
-                felt.has(view.slug) ? { felt: felt.get(view.slug).has(self[0]) } : undefined,
-            );
+            const query = view.query(self, shape, {
+                ...(felt.has(view.slug) ? { felt: felt.get(view.slug).has(self[0]) } : {}),
+                ...(calendarAddress(record.resolvedCalendar) ?
+                    { calendar: calendarAddress(record.resolvedCalendar) }
+                :   {}),
+            });
             if (!query) continue;
             const has =
                 owned.has(view.slug) ?

package/engine/helpers.mjs

@@ -26,6 +26,7 @@
  */
 
 import { renderAlerts } from "./content-alerts.mjs";
+import { renderRuns } from "./content-scripts.mjs";
 import { buildReferenceTargets } from "./reference-targets.mjs";
 import { standingsDigest } from "./standings.mjs";
 
@@ -224,10 +225,15 @@ md.renderer.rules.footnote_open = (tokens, idx, options, env, renderer) => {
  * @param {(address: string) => string|undefined} [resolveRole] - From a
  *   picture's address to the role its asset declares — see
  *   {@link module:engine/content-figures.scanFigures}.
+ * @param {import("./content-scripts.mjs").RunContext} [runs] - The package's
+ *   languages, faces and maps. Given, text marked with `lang=`, `font=` and
+ *   `map=` is rewritten first, so it is tagged for its language, mapped and
+ *   set in its font.
  * @returns {string} The rendered HTML.
  */
-export function renderFoundryMarkdown(body, figures, footnoteNumbers, docId, resolveRole) {
-    const figured = renderFigureBlocks(body, (block) => md.render(block), figures, {
+export function renderFoundryMarkdown(body, figures, footnoteNumbers, docId, resolveRole, runs) {
+    const marked = runs ? renderRuns(body, runs, undefined, { target: "foundry" }).markdown : body;
+    const figured = renderFigureBlocks(marked, (block) => md.render(block), figures, {
         resolveRole,
     });
     const blocks = renderBlocks(figured.markdown, "foundry");

package/engine/index-records.mjs

@@ -62,8 +62,10 @@ export const DERIVED_KEYS = Object.freeze([
     "documents",
     "asset",
     "resolvedDates",
+    "resolvedCalendar",
     "citations",
     "names",
+    "runs",
 ]);
 
 /**

package/engine/infobox.mjs

@@ -128,6 +128,7 @@ import {
     standingLead,
 } from "./standings.mjs";
 import { AddressEntries } from "./address-values.mjs";
+import { noteCalendar } from "./note-calendars.mjs";
 
 /**
  * How a section arranges what it holds.
@@ -1066,15 +1067,10 @@ function noteBox(
                 : parsed?.qualifier ? dates.eras?.get(parsed.qualifier)
                 : null;
             let printable = null;
-            if (parsed?.known && data.calendar) {
+            const calendar = noteCalendar(fm, dates);
+            if (parsed?.known && calendar) {
                 try {
-                    printable = formatDateInCalendar(
-                        parsed,
-                        isAddressTuple(data.calendar) ?
-                            renderAddress(data.calendar)
-                        :   data.calendar,
-                        dates,
-                    );
+                    printable = formatDateInCalendar(parsed, calendar, dates);
                 } catch {
                     // The calendar reference is checked at the authored field.
                 }

package/engine/journals.mjs

@@ -485,10 +485,12 @@ function soleFigurePicture(figure, page) {
  * @param {Map<string, number>} footnoteNumbers - Shared across the note.
  * @param {(address: string) => string|undefined} [resolveRole] - See
  *   {@link splitPages}.
+ * @param {import("./content-scripts.mjs").RunContext} [runs] - The package's
+ *   languages, faces and maps — see {@link module:engine/helpers.renderFoundryMarkdown}.
  * @returns {{name: string, type: "image", src: string, image: {caption?: string}}
  *   |{name: string, type: "text", text: {format: number, content: string}}}
  */
-function buildFigurePageFields(figure, page, pageId, footnoteNumbers, resolveRole) {
+function buildFigurePageFields(figure, page, pageId, footnoteNumbers, resolveRole, runs) {
     const picture = soleFigurePicture(figure, page);
     if (picture && !captionCarriesMarkup(figure.caption)) {
         let src = picture;
@@ -515,6 +517,7 @@ function buildFigurePageFields(figure, page, pageId, footnoteNumbers, resolveRol
         footnoteNumbers,
         pageId,
         resolveRole,
+        runs,
     );
     return {
         name: figure.label || captionPageName(figure.caption),
@@ -547,13 +550,15 @@ function buildFigurePageFields(figure, page, pageId, footnoteNumbers, resolveRol
  *   carries its own figure already, from {@link splitPages}.
  * @param {(address: string) => string|undefined} [resolveRole] - See
  *   {@link splitPages}.
+ * @param {import("./content-scripts.mjs").RunContext} [runs] - The package's
+ *   languages, faces and maps — see {@link module:engine/helpers.renderFoundryMarkdown}.
  * @returns {Array<{_id: string, name: string, type: string,
  *   title: {show: boolean, level: number},
  *   text: {format: number, content: string}, _key: string,
  *   ownership?: {default: number}}>} The page documents, in order.
  * @throws {Error} When the note has no content at all, or repeats an anchor.
  */
-export function buildPages(rawPages, entryId, noteName, figures, resolveRole) {
+export function buildPages(rawPages, entryId, noteName, figures, resolveRole, runs) {
     if (rawPages.length === 0) {
         throw new Error(
             `note "${noteName}" has no Introduction content and no H1 headings — nothing to compile`,
@@ -573,7 +578,7 @@ export function buildPages(rawPages, entryId, noteName, figures, resolveRole) {
         const withheld = (page.classes ?? []).includes(WITHHELD_CLASS);
         const fields =
             page.figure ?
-                buildFigurePageFields(page.figure, page, pageId, footnoteNumbers, resolveRole)
+                buildFigurePageFields(page.figure, page, pageId, footnoteNumbers, resolveRole, runs)
             :   {
                     name: page.name,
                     type: "text",
@@ -587,6 +592,7 @@ export function buildPages(rawPages, entryId, noteName, figures, resolveRole) {
                                     footnoteNumbers,
                                     pageId,
                                     resolveRole,
+                                    runs,
                                 )
                             :   "",
                     },
@@ -638,6 +644,8 @@ export function buildPages(rawPages, entryId, noteName, figures, resolveRole) {
  *   name reads `Map 1` rather than `Figure 1` where it is due — see
  *   {@link module:engine/content-figures.scanFigures}.
  * @param {import("./content-session.mjs").ContentSyntax} [params.syntax] - Session scanner projections.
+ * @param {import("./content-scripts.mjs").RunContext} [params.runs] - The package's
+ *   languages, faces and maps — see {@link module:engine/helpers.renderFoundryMarkdown}.
  * @returns {object} The JournalEntry document, keyed for the pack.
  */
 export function buildJournalEntry({
@@ -651,6 +659,7 @@ export function buildJournalEntry({
     notice = "",
     resolveRole,
     syntax,
+    runs,
 }) {
     const rawPages = splitPages(markdown, leadName, resolveRole, syntax);
     const pages = buildPages(
@@ -659,6 +668,7 @@ export function buildJournalEntry({
         name,
         scanFigures(markdown, { resolveRole }).figures,
         resolveRole,
+        runs,
     );
     for (const box of infoboxes) {
         const pageId = makeId("journal-infobox-page", `${id}:${box.id}`);
@@ -844,6 +854,7 @@ export class Journals extends BasePackCompiler {
                 .filter(Boolean)
                 .join("\n\n"),
             resolveRole: (pathname) => roles.get(pathname),
+            runs: this.corpus?.runs,
             infoboxes: boxes.map((box) => ({
                 id: box.id,
                 name: `${