@heroiclands/package-build 22.16.0 → 22.17.0

package/engine/note-dates.mjs

@@ -14,20 +14,27 @@
 /**
  * Parse authored note dates into records used by content checks and renderers.
  *
- * A neutral day is `<year>.<day>[:HHMMSS]`, where `day` is an ordinal within
- * the world's year. A named date is `datefrom <calendar> <date>`; its calendar
- * and era resolve the value on the neutral timeline. Either form accepts a
- * leading `~` for approximation. `unknown` is unordered.
+ * A neutral date is `<year>[.<day>[:HHMMSS]]`, where `day` is an ordinal
+ * within the world's year. A bare year spans that year; a day spans that day;
+ * a clock time identifies a second. A named date uses the `datefrom` form;
+ * its calendar and era resolve the value on the neutral timeline.
+ * Either form accepts `~` for uncertainty beyond its stated interval.
+ * `unknown` is unordered.
  *
  * `text` keeps the authored spelling. `canonicalYear` and `sort` are set for
- * neutral and resolved named dates. Resolved dates also carry `canonicalDay`,
- * the ordinal day within the neutral year.
+ * neutral and resolved named dates. A neutral year retains `precision: "year"`
+ * and has no `canonicalDay`; day one is used only to calculate its bounds.
  *
  * @module
  */
 
 import { ADDRESS_SEGMENT_PATTERN } from "./address-charset.mjs";
 import { addressedCalendarDate } from "./calendar-human.mjs";
+import {
+    calendarFormatHasClock,
+    formatCalendarPattern,
+    selectCalendarFormat,
+} from "./calendar-format.mjs";
 import {
     calendarStructure,
     canonicalDateFromOffset,
@@ -188,10 +195,7 @@ export function parseNoteDate(value, options) {
     };
 
     const resolveEra = (parsed, reckoning, label) => {
-        if (!ignoreEraBounds && parsed.year < 0 && reckoning.firstEra === false)
-            return refuse(
-                `${subject} counts backward from ${label}, but only the first era of a calendar may do so`,
-            );
+        if (parsed.year < 1) return refuse(`${subject} needs a positive year in ${label}`);
         if (!Number.isSafeInteger(daysPerYear) || daysPerYear < 1)
             return refuse(`${subject} needs the world's year length to resolve ${label}`);
         const { months } = calendarStructure(reckoning.calendar);
@@ -207,7 +211,7 @@ export function parseNoteDate(value, options) {
             );
         const ordinal = dayOfYear(months, parsed.month ?? 1, parsed.day ?? 1);
         const start = canonicalDayOffset(reckoning.epochYear, reckoning.epochDay, 1, daysPerYear);
-        const yearOffset = parsed.year > 0 ? parsed.year - 1 : parsed.year;
+        const yearOffset = reckoning.beforeEra ? -parsed.year : parsed.year - 1;
         const offset = start + yearOffset * daysPerYear + ordinal - 1;
         if (!Number.isSafeInteger(offset))
             return refuse(`${subject} lies outside the supported canonical day range`);
@@ -283,10 +287,10 @@ export function parseNoteDate(value, options) {
             `${subject} writes year 0, and no reckoning has one — the years either ` +
                 `side of an epoch are -1 and 1`,
         );
-    if (field && !/^-?\d+\.\d+(?::\d{6})?$/.test(unmarked))
+    if (field && !/^-?\d+(?:\.\d+(?::\d{6})?)?$/.test(unmarked))
         return refuse(
             `${subject} is not a frontmatter date — write ` +
-                "`<year>.<day>[:HHMMSS]` or `datefrom <calendar> <date>`",
+                "`<year>[.<day>[:HHMMSS]]` or `datefrom <calendar> <date>`",
         );
     if (unmarked.includes(".")) {
         const canonical = parseCanonicalDate(unmarked, daysPerYear ?? Number.MAX_SAFE_INTEGER);
@@ -301,13 +305,13 @@ export function parseNoteDate(value, options) {
                     day: canonical.day,
                     approximate: approximateInput,
                     precision: "day",
-                    canonicalYear: canonical.year,
+                    canonicalYear: canonicalYear(canonical.year),
                     canonicalDay: canonical.day,
                     spanDays: 1,
                     ...(canonical.seconds === undefined ? {} : { seconds: canonical.seconds }),
                     sort:
                         Number.isSafeInteger(daysPerYear) ?
-                            canonical.year +
+                            canonicalYear(canonical.year) +
                             (canonical.day - 1 + (canonical.seconds ?? 0) / 86400) / daysPerYear
                         :   null,
                 },
@@ -348,7 +352,7 @@ export function parseNoteDate(value, options) {
         }
         return refuse(
             `${subject} is not a date — write ` +
-                `\`<year>.<day>[:HHMMSS]\` or ` +
+                `\`<year>[.<day>[:HHMMSS]]\` or ` +
                 `\`datefrom <calendar> <date>\``,
         );
     }
@@ -515,17 +519,17 @@ export function calendarEras(reference, context) {
 }
 
 /** Print a resolved date using the era active in one addressed calendar. */
-export function formatDateInCalendar(date, reference, context) {
+export function formatDateInCalendar(date, reference, context, formatName) {
     const eras = calendarEras(reference, context);
     const chosen = eraCovering(date, eras, context?.daysPerYear);
     const name = String(reference ?? "");
     if (context?.eras?.get(name)?.era && chosen === null)
         throw new RangeError(`date falls outside calendar era ${name}`);
-    return formatNoteDate(date, chosen, context?.daysPerYear);
+    return formatNoteDate(date, chosen, context?.daysPerYear, formatName);
 }
 
 /** Print a resolved date in one era, retaining its authored precision. */
-export function formatNoteDate(date, era, daysPerYear) {
+export function formatNoteDate(date, era, daysPerYear, formatName) {
     if (!date?.known || !Number.isSafeInteger(date.canonicalYear)) return null;
     if (!era) return { era: null, year: eraYear(date.canonicalYear), text: date.text, prose: null };
     if (!Number.isSafeInteger(daysPerYear) || !Number.isSafeInteger(date.spanDays)) return null;
@@ -538,7 +542,8 @@ export function formatNoteDate(date, era, daysPerYear) {
         canonicalDayOffset(target.epochYear, target.epochDay ?? 1, 1, daysPerYear);
     const delta = start - epoch;
     const cycle = Math.floor(delta / daysPerYear);
-    const year = cycle >= 0 ? cycle + 1 : cycle;
+    const year = target.beforeEra ? -cycle : cycle + 1;
+    if (year < 1) return null;
     if (Math.floor((delta + date.spanDays - 1) / daysPerYear) !== cycle) return null;
 
     let month = null;
@@ -565,14 +570,37 @@ export function formatNoteDate(date, era, daysPerYear) {
         month === null ? null : calendarStructure(target.calendar).months?.[month - 1]?.name;
     const eraName =
         target.abbreviation || target.marker || target.name || target.era.split(".").at(-1);
-    const text = `${date.approximate ? "~" : ""}${day === null ? "" : `${day} `}${monthName ? `${monthName} ` : ""}${year} ${eraName}${clock}`;
+    let text = `${date.approximate ? "~" : ""}${day === null ? "" : `${day} `}${monthName ? `${monthName} ` : ""}${year} ${eraName}${clock}`;
+    if (target.calendar?.formats) {
+        const { pattern } = selectCalendarFormat(target.calendar, formatName);
+        const hasClock = calendarFormatHasClock(pattern);
+        const rendered = formatCalendarPattern(
+            pattern,
+            {
+                calendar: target.calendar,
+                era: target,
+                eraYear: year,
+                calendarYear: target.beforeEra ? -year : target.startYear + year - 1,
+                month,
+                day,
+                dayOfYear: (((delta % daysPerYear) + daysPerYear) % daysPerYear) + 1,
+                seconds: date.seconds,
+                canonicalOffset: start,
+                calendarEpochOffset: target.calendarEpochOffset,
+            },
+            date.precision,
+            date.seconds !== undefined,
+        );
+        text = `${date.approximate ? "~" : ""}${rendered}${date.seconds !== undefined && !hasClock ? clock : ""}`;
+    }
     const digits = `${Math.abs(year)}${month === null ? "" : `/${month}`}${day === null ? "" : `/${day}${clock.replaceAll(":", "").replace(/^ /, ":")}`}`;
     const label =
         typeof target.label === "string" ?
             target.label
         :   target.label?.[year < 0 ? "before" : "after"];
     const prose =
-        typeof label === "string" && label.includes("{date}") ?
+        target.calendar?.formats ? null
+        : typeof label === "string" && label.includes("{date}") ?
             label.replace("{date}", `${date.approximate ? "~" : ""}${digits}`)
         :   null;
     return { era, year, month, day, text, prose };

package/engine/reckoning-markers.mjs

@@ -1,70 +1,64 @@
-/*
- * 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 { DATEFROM_PATTERN, parseNoteDate } from "./note-dates.mjs";
-import { eraNames } from "./calendar-human.mjs";
-import { addressSuffixes, renderAddress } from "./address-render.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 {{eras: Map<string, object>, markers: Map<string, object>, findings: object[]}} Resolved eras, markers, and errors.
- */
+/** Resolve calendar eras on the canonical day axis. */
 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 qualifiers = new Map();
+    const markerOwners = new Map();
+    const calendarRows = [];
 
-    const location = (row, key) => ({
-        ...(row.note.file === undefined ? {} : { file: row.note.file }),
-        ...(row.note.raw === undefined ?
+    const location = (note, position, key) => ({
+        ...(note.file === undefined ? {} : { file: note.file }),
+        ...(note.raw === undefined ?
             {}
-        :   positionOfFrontmatterPath(row.note.raw, ["data", "eras", row.position, key])),
+        :   positionOfFrontmatterPath(note.raw, ["data", "eras", 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);
-    };
+    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 rows = fm.data?.eras;
+        const data = fm.data ?? {};
+        const rows = 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;
+        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", "epoch"])),
+                severity: "error",
+                message:
+                    "data.epoch must be a canonical <year>.<day> anchoring calendar year 1, day 1",
+            });
+            continue;
+        }
+        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 ?
@@ -73,235 +67,139 @@ export function resolveReckoningMarkers(index, daysPerYear) {
             const row = {
                 key,
                 era: short,
-                calendar: fm.data,
-                marker: era.marker,
+                calendar: data,
                 calendarShortcode: fm.shortcode,
+                note,
+                position,
+                start: era.start,
                 name: era.name,
                 abbreviation: era.abbreviation,
+                marker: era.marker,
                 label: era.label,
-                start: era.start,
-                end: era.end,
-                note,
-                position,
             };
-            if (declared.has(key)) {
-                return;
+            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);
             }
-            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) {
+                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.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",
+            if (era.end !== undefined)
+                error(
+                    note,
+                    position,
+                    "end",
+                    "an era ends when the next calendar year era begins; omit end",
                 );
-                return;
-            }
-            if (markerKeys.has(era.marker)) {
-                finding(row, "marker", `reckoning marker ${era.marker} is declared more than once`);
-                return;
-            }
-            markerKeys.set(era.marker, key);
-        });
+        }
+        calendarRows.push({ note, declared, epochOffset });
     }
 
-    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,
+    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",
             );
-            finding(row, "start", `calendar era cycle includes ${members.join(" → ")}`);
-            for (const member of visiting.slice(visiting.indexOf(key))) failed.add(member);
-            return null;
-        }
-        visiting.push(key);
-        if (row.start === undefined || row.start === null) {
-            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 =
-            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,
-                ...location(row, "start"),
-                raw: row.note.raw,
-                keyPath: ["data", "eras", row.position, "start"],
-            });
-            findings.push(...parsed.findings);
-            if (
-                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,
-                };
-                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.pop();
-        return eras.get(key) ?? null;
-    }
-    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,
-            file: row.note.file,
-            raw: row.note.raw,
-            keyPath: ["data", "eras", row.position, "end"],
-        });
-        findings.push(...parsed.findings);
-        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`,
+        if (firstRows.length !== 1)
+            error(
+                note,
+                firstRows[0]?.position ?? 0,
+                "start",
+                "a calendar needs exactly one era with start: 1",
             );
-            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 ??
-                        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) {
-            finding(row, "end", `calendar era ${row.era} ends before its start`);
-            continue;
-        }
-        entry.endOffset = endOffset;
-    }
-    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,
+        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",
-                    `calendar eras ${row.era} and ${next.era} must begin in increasing order`,
+                    "an era start is null or a positive integer calendar year",
                 );
                 continue;
             }
-            if (entry.endOffset !== undefined && entry.endOffset >= following.startOffset) {
-                finding(next, "start", `calendar eras ${row.era} and ${next.era} overlap`);
+            if (byStart.has(row.start)) {
+                error(note, row.position, "start", `calendar eras cannot share start ${row.start}`);
+                continue;
+            }
+            byStart.set(row.start, row);
+        }
+        const ordered = [...byStart.values()].sort((a, b) =>
+            a.start === null ? -1
+            : b.start === null ? 1
+            : a.start - b.start,
+        );
+        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;
             }
-            if (entry.endOffset === undefined) entry.endOffset = following.startOffset - 1;
+            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);
         }
     }
+    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 {{eras: Map<string, object>, 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 { eras: new Map(), markers: new Map(), daysPerYear: undefined, findings: [] };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "22.16.0",
+    "version": "22.17.0",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",