@heroiclands/package-build 22.15.1 → 22.17.0

package/engine/reckoning-markers.mjs

@@ -1,198 +1,208 @@
-/*
- * 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
- */
+/* 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";
+import {
+    canonicalDateFromOffset,
+    canonicalDayOffset,
+    canonicalYear,
+    parseCanonicalDate,
+} from "./calendars.mjs";
+import { renderAddress } from "./address-render.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.
- */
+/** Resolve calendar eras on the canonical day axis. */
 export function resolveReckoningMarkers(index, daysPerYear) {
-    const declared = new Map();
+    const eras = new Map();
     const markers = new Map();
     const findings = [];
+    const qualifiers = new Map();
+    const markerOwners = new Map();
+    const calendarRows = [];
+
+    const location = (note, position, key) => ({
+        ...(note.file === undefined ? {} : { file: note.file }),
+        ...(note.raw === undefined ?
+            {}
+        :   positionOfFrontmatterPath(note.raw, ["data", "eras", position, key])),
+    });
+    const error = (note, position, key, message) =>
+        findings.push({ ...location(note, position, key), severity: "error", message });
 
     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 = {
+        const data = fm.data ?? {};
+        const rows = data.eras;
+        if (!Array.isArray(rows)) continue;
+        if (!Number.isSafeInteger(daysPerYear) || daysPerYear < 1) continue;
+        const epochText = String(data.epoch ?? "");
+        const epoch = parseCanonicalDate(epochText, daysPerYear);
+        if (!epoch || epoch.year === 0 || epoch.seconds !== undefined) {
+            findings.push({
                 ...(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 }),
+                :   positionOfFrontmatterPath(note.raw, ["data", "epoch"])),
                 severity: "error",
-                message: `reckoning marker ${marker} needs an era start`,
+                message:
+                    "data.epoch must be a canonical <year>.<day> anchoring calendar year 1, day 1",
             });
-            failed.add(marker);
+            continue;
         }
-        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);
+        const epochOffset = canonicalDayOffset(
+            canonicalYear(epoch.year),
+            epoch.day,
+            1,
+            daysPerYear,
+        );
+        const pkg = fm.package ?? note.package ?? index?.contentPackage;
+        const declared = [];
+        for (const [position, era] of rows.entries()) {
+            if (!era || typeof era.shortcode !== "string" || !era.shortcode || !fm.shortcode)
+                continue;
+            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: data,
+                calendarShortcode: fm.shortcode,
+                note,
+                position,
+                start: era.start,
+                name: era.name,
+                abbreviation: era.abbreviation,
+                marker: era.marker,
+                label: era.label,
+            };
+            declared.push(row);
+            const aliases = [short, `lore-${short}`, `note-lore-${short}`];
+            for (const alias of aliases) {
+                if (qualifiers.has(alias) && qualifiers.get(alias) !== key)
+                    qualifiers.set(alias, null);
+                else qualifiers.set(alias, key);
             }
+            if (era.marker !== undefined) {
+                if (typeof era.marker !== "string" || !/^[A-Z][A-Z0-9]*$/.test(era.marker))
+                    error(
+                        note,
+                        position,
+                        "marker",
+                        "an era marker needs uppercase letters and digits",
+                    );
+                else if (markerOwners.has(era.marker))
+                    error(
+                        note,
+                        position,
+                        "marker",
+                        `reckoning marker ${era.marker} is declared more than once`,
+                    );
+                else markerOwners.set(era.marker, key);
+            }
+            if (era.end !== undefined)
+                error(
+                    note,
+                    position,
+                    "end",
+                    "an era ends when the next calendar year era begins; omit end",
+                );
         }
-        visiting.delete(marker);
-        return markers.get(marker) ?? null;
+        calendarRows.push({ note, declared, epochOffset });
     }
-    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;
+
+    for (const { note, declared, epochOffset } of calendarRows) {
+        const nullRows = declared.filter((row) => row.start === null);
+        const firstRows = declared.filter((row) => row.start === 1);
+        if (nullRows.length !== 1)
+            error(
+                note,
+                nullRows[0]?.position ?? 0,
+                "start",
+                "a calendar needs exactly one start: null era before year 1",
+            );
+        if (firstRows.length !== 1)
+            error(
+                note,
+                firstRows[0]?.position ?? 0,
+                "start",
+                "a calendar needs exactly one era with start: 1",
+            );
+        const byStart = new Map();
+        for (const row of declared) {
+            if (row.start !== null && (!Number.isSafeInteger(row.start) || row.start < 1)) {
+                error(
+                    note,
+                    row.position,
+                    "start",
+                    "an era start is null or a positive integer calendar year",
+                );
+                continue;
+            }
+            if (byStart.has(row.start)) {
+                error(note, row.position, "start", `calendar eras cannot share start ${row.start}`);
+                continue;
+            }
+            byStart.set(row.start, row);
         }
-        const firstEndDay = canonicalDayOffset(
-            parsed.date.canonicalYear,
-            parsed.date.canonicalDay ?? 1,
-            1,
-            daysPerYear,
+        const ordered = [...byStart.values()].sort((a, b) =>
+            a.start === null ? -1
+            : b.start === null ? 1
+            : a.start - b.start,
         );
-        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;
+        for (const [position, row] of ordered.entries()) {
+            const startOffset =
+                row.start === null ? epochOffset : epochOffset + (row.start - 1) * daysPerYear;
+            if (!Number.isSafeInteger(startOffset)) {
+                error(
+                    note,
+                    row.position,
+                    "start",
+                    "era start lies outside the supported day range",
+                );
+                continue;
+            }
+            const startDate = canonicalDateFromOffset(startOffset, 1, daysPerYear);
+            const next = ordered[position + 1];
+            const endOffset = next ? epochOffset + (next.start - 1) * daysPerYear - 1 : undefined;
+            const entry = {
+                era: row.era,
+                qualifier: row.key,
+                marker: row.marker,
+                firstEra: row.start === null,
+                beforeEra: row.start === null,
+                startYear: row.start,
+                calendar: row.calendar,
+                calendarShortcode: row.calendarShortcode,
+                name: row.name,
+                abbreviation: row.abbreviation,
+                label: row.label,
+                epochYear: startDate.year,
+                epochDay: startDate.day,
+                calendarEpochOffset: epochOffset,
+                startOffset,
+                ...(endOffset === undefined ? {} : { endOffset }),
+            };
+            eras.set(row.key, entry);
+            if (row.marker && markerOwners.get(row.marker) === row.key)
+                markers.set(row.marker, entry);
         }
-        entry.endOffset = endOffset;
     }
-    return { markers, findings };
+    for (const [alias, key] of qualifiers) {
+        if (key === null) eras.set(alias, { ambiguous: true });
+        else if (eras.has(key)) eras.set(alias, eras.get(key));
+    }
+    return { eras, markers, findings };
 }
 
-/** One resolved date context per corpus index, shared by its note checks. */
+/** One resolved date context per corpus index. */
 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[]}}
- */
+/** Read the world's year length and resolve every calendar era in one corpus. */
 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