@heroiclands/package-build 22.15.0 → 22.16.0

package/engine/reckoning-markers.mjs

@@ -10,7 +10,9 @@
 
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
 import { canonicalDayOffset, daysInMonth } from "./calendars.mjs";
-import { parseNoteDate } from "./note-dates.mjs";
+import { DATEFROM_PATTERN, parseNoteDate } from "./note-dates.mjs";
+import { eraNames } from "./calendar-human.mjs";
+import { addressSuffixes, renderAddress } from "./address-render.mjs";
 
 /**
  * Resolve every declared reckoning marker against its calendar and era start.
@@ -18,126 +20,205 @@ import { parseNoteDate } from "./note-dates.mjs";
  *
  * @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.
+ * @returns {{eras: Map<string, object>, markers: Map<string, object>, findings: object[]}} Resolved eras, markers, and errors.
  */
 export function resolveReckoningMarkers(index, daysPerYear) {
     const declared = new Map();
+    const qualifiers = new Map();
+    const markerKeys = new Map();
+    const eras = new Map();
     const markers = new Map();
     const findings = [];
+    const failed = new Set();
+    const visiting = [];
+
+    const location = (row, key) => ({
+        ...(row.note.file === undefined ? {} : { file: row.note.file }),
+        ...(row.note.raw === undefined ?
+            {}
+        :   positionOfFrontmatterPath(row.note.raw, ["data", "eras", row.position, key])),
+    });
+    const finding = (row, key, message) =>
+        findings.push({
+            ...location(row, key),
+            severity: "error",
+            message,
+        });
+    const alias = (qualifier, key) => {
+        if (qualifiers.has(qualifier) && qualifiers.get(qualifier) !== key)
+            qualifiers.set(qualifier, null);
+        else qualifiers.set(qualifier, key);
+    };
 
     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"])),
+        const rows = fm.data?.eras;
+        if (!Array.isArray(rows)) continue;
+        rows.forEach((era, position) => {
+            if (
+                !era ||
+                typeof era.shortcode !== "string" ||
+                !era.shortcode ||
+                typeof fm.shortcode !== "string" ||
+                !fm.shortcode
+            )
+                return;
+            const pkg = fm.package ?? note.package ?? index?.contentPackage;
+            const short = `${fm.shortcode}.${era.shortcode}`;
+            const key =
+                pkg ?
+                    renderAddress({ package: pkg, system: "note", type: "lore", shortcode: short })
+                :   short;
+            const row = {
+                key,
+                era: short,
+                calendar: fm.data,
+                marker: era.marker,
+                calendarShortcode: fm.shortcode,
+                name: era.name,
+                abbreviation: era.abbreviation,
+                label: era.label,
+                start: era.start,
+                end: era.end,
+                note,
+                position,
             };
-            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",
-                });
+            if (declared.has(key)) {
                 return;
             }
-            if (declared.has(marker)) {
-                findings.push({
-                    ...at,
-                    severity: "error",
-                    message: `reckoning marker ${marker} is declared more than once`,
-                });
+            declared.set(key, row);
+            alias(short, key);
+            if (pkg) {
+                alias(
+                    renderAddress({ package: pkg, system: "note", type: "lore", shortcode: short }),
+                    key,
+                );
+                alias(`note-lore-${short}`, key);
+                alias(`lore-${short}`, key);
+            }
+            if (era.marker === undefined) return;
+            if (typeof era.marker !== "string" || !/^[A-Z][A-Z0-9]*$/.test(era.marker)) {
+                finding(
+                    row,
+                    "marker",
+                    "an era marker is uppercase letters and digits, starting with a letter",
+                );
                 return;
             }
-            declared.set(marker, {
-                marker,
-                era: `${fm.shortcode}.${row.shortcode}`,
-                calendar: fm.data,
-                start: row.start,
-                end: row.end,
-                note,
-                position,
-            });
+            if (markerKeys.has(era.marker)) {
+                finding(row, "marker", `reckoning marker ${era.marker} is declared more than once`);
+                return;
+            }
+            markerKeys.set(era.marker, key);
         });
     }
 
-    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);
+    for (const [qualifier, key] of qualifiers)
+        if (key === null) eras.set(qualifier, { ambiguous: true });
+
+    function resolve(key) {
+        if (key === null || !declared.has(key) || failed.has(key)) return null;
+        const row = declared.get(key);
+        if (eras.has(key)) return eras.get(key);
+        if (visiting.includes(key)) {
+            const members = [...visiting.slice(visiting.indexOf(key)), key].map(
+                (member) => declared.get(member).era,
+            );
+            finding(row, "start", `calendar era cycle includes ${members.join(" → ")}`);
+            for (const member of visiting.slice(visiting.indexOf(key))) failed.add(member);
             return null;
         }
-        visiting.add(marker);
+        visiting.push(key);
         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);
+            finding(row, "start", `calendar era ${row.era} needs a start`);
+            failed.add(key);
         }
+        const source = typeof row.start === "string" ? row.start.trim() : "";
+        const marker = /^([A-Z][A-Z0-9]*)\(/.exec(source)?.[1];
+        const qualifier = /\s+([^\s]+\.[^\s]+)$/.exec(source)?.[1];
+        const conversion = DATEFROM_PATTERN.exec(source);
+        const convertedRef = conversion?.[1];
+        const convertedDate = conversion?.[2];
+        const convertedRows =
+            convertedRef ?
+                [...declared.values()].filter((candidate) => {
+                    const fm = candidate.note.fm ?? candidate.note.frontmatter ?? candidate.note;
+                    const pkg = fm.package ?? candidate.note.package ?? index?.contentPackage;
+                    if (!pkg) return convertedRef === candidate.calendarShortcode;
+                    return addressSuffixes({
+                        package: pkg,
+                        system: "note",
+                        type: "lore",
+                        shortcode: candidate.calendarShortcode,
+                    }).includes(convertedRef);
+                })
+            :   [];
+        const convertedTargets = convertedRows.filter((candidate) =>
+            eraNames(candidate).some((name) =>
+                convertedDate?.toLowerCase().endsWith(` ${name.toLowerCase()}`),
+            ),
+        );
+        if (convertedTargets.length === 0 && convertedRows.length === 1)
+            convertedTargets.push(convertedRows[0]);
         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)) {
+            marker ? markerKeys.get(marker)
+            : qualifier ? qualifiers.get(qualifier)
+            : convertedTargets.length === 1 ? convertedTargets[0].key
+            : null;
+        if (dependency && !failed.has(key)) resolve(dependency);
+        if (!failed.has(key)) {
             const parsed = parseNoteDate(row.start, {
                 markers,
+                eras,
                 daysPerYear,
                 field: "data.eras.start",
                 allowUnknown: false,
-                file: row.note.file,
+                ...location(row, "start"),
                 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")
+                Number.isSafeInteger(parsed.date?.canonicalYear) &&
+                parsed.findings.every((item) => item.severity !== "error")
             ) {
                 const entry = {
                     era: row.era,
+                    qualifier: row.key,
+                    marker: row.marker,
+                    firstEra: row.position === 0,
                     calendar: row.calendar,
+                    calendarShortcode: row.calendarShortcode,
+                    name: row.name,
+                    abbreviation: row.abbreviation,
+                    label: row.label,
                     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);
-            }
+                if (Number.isSafeInteger(daysPerYear) && daysPerYear > 0)
+                    entry.startOffset = canonicalDayOffset(
+                        entry.epochYear,
+                        entry.epochDay,
+                        1,
+                        daysPerYear,
+                    );
+                eras.set(key, entry);
+                for (const [name, owner] of qualifiers) if (owner === key) eras.set(name, entry);
+                if (row.marker && markerKeys.get(row.marker) === key)
+                    markers.set(row.marker, entry);
+            } else failed.add(key);
         }
-        visiting.delete(marker);
-        return markers.get(marker) ?? null;
+        visiting.pop();
+        return eras.get(key) ?? null;
     }
-    for (const marker of declared.keys()) resolve(marker);
-    for (const [marker, row] of declared) {
-        const entry = markers.get(marker);
+    for (const key of declared.keys()) resolve(key);
+    for (const row of declared.values()) {
+        const entry = eras.get(row.key);
         if (!entry || row.end === undefined || row.end === null) continue;
         const parsed = parseNoteDate(row.end, {
             markers,
+            eras,
             daysPerYear,
             field: "data.eras.end",
             allowUnknown: false,
@@ -146,13 +227,13 @@ export function resolveReckoningMarkers(index, daysPerYear) {
             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`,
-                });
+        if (!Number.isSafeInteger(parsed.date?.canonicalYear)) continue;
+        if (!Number.isSafeInteger(daysPerYear) || daysPerYear < 1) {
+            finding(
+                row,
+                "end",
+                `calendar era ${row.era} needs the world's year length to bound its end`,
+            );
             continue;
         }
         const firstEndDay = canonicalDayOffset(
@@ -164,21 +245,52 @@ export function resolveReckoningMarkers(index, 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
+                (daysInMonth(
+                    markers.get(parsed.date.marker)?.calendar ??
+                        eras.get(parsed.date.qualifier)?.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`,
-            });
+            finding(row, "end", `calendar era ${row.era} ends before its start`);
             continue;
         }
         entry.endOffset = endOffset;
     }
-    return { markers, findings };
+    const calendars = new Map();
+    for (const row of declared.values()) {
+        const rows = calendars.get(row.note) ?? [];
+        rows.push(row);
+        calendars.set(row.note, rows);
+    }
+    for (const rows of calendars.values()) {
+        for (let position = 0; position < rows.length; position++) {
+            const row = rows[position];
+            const entry = eras.get(row.key);
+            if (!entry || !Number.isSafeInteger(entry.startOffset)) continue;
+            entry.firstEra = position === 0;
+            const next = rows[position + 1];
+            if (!next) continue;
+            const following = eras.get(next.key);
+            if (!following || !Number.isSafeInteger(following.startOffset)) continue;
+            if (following.startOffset <= entry.startOffset) {
+                finding(
+                    next,
+                    "start",
+                    `calendar eras ${row.era} and ${next.era} must begin in increasing order`,
+                );
+                continue;
+            }
+            if (entry.endOffset !== undefined && entry.endOffset >= following.startOffset) {
+                finding(next, "start", `calendar eras ${row.era} and ${next.era} overlap`);
+                continue;
+            }
+            if (entry.endOffset === undefined) entry.endOffset = following.startOffset - 1;
+        }
+    }
+    return { eras, markers, findings };
 }
 
 /** One resolved date context per corpus index, shared by its note checks. */
@@ -188,11 +300,11 @@ 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[]}}
+ * @returns {{eras: Map<string, object>, 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: [] };
+        return { eras: new Map(), markers: new Map(), daysPerYear: undefined, findings: [] };
     const cached = contexts.get(index);
     if (cached) return cached;
     const world = (index.notes ?? []).find((note) => {

package/engine/scenes.mjs

@@ -39,7 +39,7 @@
  * rather than stored. It is the same vocabulary the link manifest uses.
  *
  * Not a standalone script — exports the `Scenes` compiler class, imported and
- * driven by `packages/content-build/engine/generate.mjs` (via `npm run build:compiledb`).
+ * driven by `packages/package-build/engine/generate.mjs` (via `npm run build:compiledb`).
  *
  * The walk itself — filtering by type, expanding tables, converting
  * wikilinks, writing the JSON and counting errors — belongs to {@link sohl.utils.packs.BasePackCompiler}; this module
@@ -499,7 +499,10 @@ export class Scenes extends BasePackCompiler {
                     // 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"),
+                    journalPack:
+                        hasBody ?
+                            this.#packRouter.resolve(fm, "JournalEntry")
+                        :   this.#packRouter.defaultOf("JournalEntry"),
                     pageIds: hasBody ? this.#pageIds(markdown, entryId, name) : new Map(),
                     knownActions: this.knownActions,
                     warnings,

package/engine/schema-check.mjs

@@ -468,7 +468,7 @@ export function compareEmittedSystem({
  *
  * - **A system**: its own `schema.json`, generated from its `src/` into
  *   `build/` by `package-build schema`.
- * - **A module**: the copy cached by `content-build deps fetch`, from the
+ * - **A module**: the copy cached by `package-build deps fetch`, from the
  *   archive of the version it pins — which is what makes the comparison happen
  *   at `verified` rather than against whatever the system's `main` holds today.
  *   That distinction is the whole of the `affiliation.subType` case.
@@ -640,7 +640,7 @@ function schemaFor(config, system = undefined) {
  * version released before the artifact existed, or a subtype the artifact does
  * not name, produces no findings — the same stance `compareFields` takes, where
  * an unknown subtype is a routing question rather than a field one. The
- * whole-build check in `content-build lint` is where a missing artifact is said
+ * whole-build check in `package-build lint` is where a missing artifact is said
  * out loud, once, instead of per note.
  *
  * @param {object} fm - The note's frontmatter.
@@ -690,7 +690,7 @@ export function checkAuthoredSystemData(
  * **Silent where there is nothing to check against**, exactly as its two
  * siblings are: a module pinning a system version released before the artifact
  * existed, or a subtype the artifact does not name, produces no findings.
- * `content-build lint` is where a missing artifact is said out loud, once.
+ * `package-build lint` is where a missing artifact is said out loud, once.
  *
  * @param {object} emitted - The `system` block the compiler produced.
  * @param {object} opts