@heroiclands/package-build 23.10.0 → 23.12.0

package/engine/being-age.mjs

@@ -11,51 +11,9 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
-/**
- * **The middle state of `age`: absent beside a dated `born`, it follows from
- * the date.**
- *
- * `age` is a three-state override — authored it wins, absent beside a dated
- * `born` it is computed, absent beside `born: unknown` or an absent `born` it
- * stays unknown. This module builds the middle state, which nothing else in
- * the toolchain does: `born` and `age` are read straight through to every
- * compiled surface exactly as authored, unless a note's own package states the
- * day the setting stops.
- *
- * ## Where the present comes from
- *
- * A world's `present` is a fact about the world, not about a calendar or a
- * build configuration — it is `data.present` on the package's own `place` note
- * of `subType: world` (or `celestial`), read through
- * {@link module:engine/calendar-notes.worldInvariants}. A package with no such
- * note states no present, computes no age, and says nothing about it: the
- * absence is silent, exactly as a package that declares no calendar is asked
- * no calendar questions.
- *
- * ## The arithmetic is on two dates, not on two years
- *
- * A year subtracted from a year is wrong whenever the birthday has not yet
- * happened in the present's year — the common shape, not the exception. So
- * {@link computeAge} compares the two dates' canonical day ordinals where an
- * era marker supplies them. The birthday that still lies ahead in the current
- * year does not count as a completed year. An unmarked slash date has no
- * calendar to convert, so it uses its written month and day as its ordinal.
- *
- * ## `~` follows the convention {@link module:engine/note-dates} sets
- *
- * A date's `~` marks the value approximate without changing what it parses to,
- * so a renderer keeps the authored text and a comparison still has a number.
- * {@link parseAgeMagnitude} draws the same distinction for `age` — the tilde,
- * the magnitude — without routing through {@link module:engine/note-dates}
- * itself: `age` is a plain count of years, not a date, so it has no month, no
- * day, no era, and — unlike a date — no refusal of `0`. Reusing the date
- * grammar's month/day/era machinery here would accept an age nothing about the
- * field means, and refuse the one age an infant can have.
- *
- * @module
- */
+/** Authored ages and setting-wide current-date age calculations. @module */
 
-import { worldInvariants } from "./calendar-notes.mjs";
+import { DEFAULT_CURRENT_DATE } from "./current-date.mjs";
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
 import { parseNoteDate } from "./note-dates.mjs";
 import { reckoningContext } from "./reckoning-markers.mjs";
@@ -107,11 +65,9 @@ export function parseAgeMagnitude(raw) {
  *
  * @param {unknown} bornRaw - The being's authored `born`, or `undefined`/`null`
  *   where it wrote none.
- * @param {unknown} presentRaw - The package's `data.present`, as
- *   {@link module:engine/calendar-notes.worldInvariants} read it, or
- *   `undefined`/`null` where the package states none.
+ * @param {unknown} presentRaw - The configured neutral current date.
  * @returns {number|null} The age, or `null` where `born` is `unknown` or
- *   absent, where no present is declared, or where either date fails to parse.
+ *   absent or future, or where either date fails to parse.
  */
 export function computeAge(bornRaw, presentRaw, dateContext = {}) {
     if (bornRaw === undefined || bornRaw === null) return null;
@@ -126,11 +82,15 @@ export function computeAge(bornRaw, presentRaw, dateContext = {}) {
     // A resolved marker supplies a canonical day. An unmarked slash date uses
     // its written month and day. Missing parts read as the first day that the
     // value can name.
-    const bornOrdinal = born.canonicalDay ?? (born.month ?? 1) * 100 + (born.day ?? 1);
-    const presentOrdinal = present.canonicalDay ?? (present.month ?? 1) * 100 + (present.day ?? 1);
+    const bornOrdinal =
+        born.canonicalDay ?? (born.month === null ? 1 : (born.month ?? 1) * 100 + (born.day ?? 1));
+    const presentOrdinal =
+        present.canonicalDay ??
+        (present.month === null ? 1 : (present.month ?? 1) * 100 + (present.day ?? 1));
     const notYetHappened = bornOrdinal > presentOrdinal;
 
-    return present.canonicalYear - born.canonicalYear - (notYetHappened ? 1 : 0);
+    const age = present.canonicalYear - born.canonicalYear - (notYetHappened ? 1 : 0);
+    return age < 0 ? null : age;
 }
 
 /**
@@ -146,8 +106,7 @@ export function computeAge(bornRaw, presentRaw, dateContext = {}) {
  * itself untouched.
  *
  * @param {object} fm - A note's frontmatter, as freshly parsed.
- * @param {unknown} presentRaw - The package's declared present, or
- *   `undefined`/`null` where it states none.
+ * @param {unknown} presentRaw - The configured neutral current date.
  * @returns {void}
  */
 export function applyComputedBeingAge(fm, presentRaw, dateContext = {}) {
@@ -171,63 +130,21 @@ export function applyComputedBeingAge(fm, presentRaw, dateContext = {}) {
 }
 
 /**
- * A being's `data.present`, read from every `place` note a batch of records or
- * frontmatter objects carries.
- *
- * Two shapes reach this by way of two thin adapters, because the callers that
- * need a present hold their notes two different ways: a flat index record
- * (`type` and `data` at the top level) and a raw walk's `{frontmatter}` pair.
- * Neither shape is the `{fm, type}` pair {@link worldInvariants} reads, so each
- * adapter states the one conversion its caller needs rather than asking every
- * caller to know it.
- *
- * @param {readonly object[]|undefined} records - Flat index records — a
- *   content-index record, or anything else spreading a note's frontmatter to
- *   its own top level.
- * @returns {unknown} The present, or `null` where no `place` note in the batch
- *   declares one.
- */
-export function presentAmongRecords(records) {
-    return worldInvariants({
-        notes: (records ?? []).map((record) => ({ fm: record, type: record?.type })),
-    }).present;
-}
-
-/**
- * The present read from a batch of raw frontmatter objects.
- *
- * @param {readonly (object|null|undefined)[]|undefined} frontmatters - One
- *   entry per note walked, as parsed — never a record.
- * @returns {unknown} The present, or `null` where none is declared.
- */
-export function presentAmongFrontmatters(frontmatters) {
-    return worldInvariants({
-        notes: (frontmatters ?? []).map((fm) => ({ fm, type: fm?.type })),
-    }).present;
-}
-
-/**
- * Check a being's authored `age` against what `born` and the package's present
- * compute.
+ * Check an authored age against the birth date and configured current date.
  *
  * Registered as `being`'s whole-note `check` in `note-vocabulary.mjs`, run the
  * way `checkPlace` and `checkCalendarNote` are — beside every other check the
  * closed `data:` container earns, with the same `index`.
  *
- * Two silences, both deliberate: beside `born: unknown` or an absent `born`
- * there is nothing to disagree with, and a package that declares no present
- * computes no age to disagree with either — both cases are read by
- * {@link computeAge} returning `null`, and neither says a word.
+ * An unknown or absent birth date supplies no computed age to compare.
  *
- * @param {object} note - The note, as the link index hands it over —
- *   {@link module:engine/calendar-notes.worldInvariants}'s `index.notes` shape.
+ * @param {object} note - The note, as the link index hands it over.
  * @param {object} [opts]
- * @param {object} [opts.index] - The link index, holding the package's `place`
- *   notes. Its absence skips the check, the way a reference check with no
- *   index skips reporting every reference as dead.
+ * @param {object} [opts.index] - Calendar context for authored birth dates.
+ * @param {string} [opts.currentDate="720.1"] - The configured neutral current date.
  * @returns {object[]} Findings — at most one `warning`, naming both values.
  */
-export function checkBeingAge(note, { index } = {}) {
+export function checkBeingAge(note, { index, currentDate = DEFAULT_CURRENT_DATE } = {}) {
     if (!isBeingType(note?.type ?? note?.fm?.type)) return [];
     const data = dataOf(note?.fm);
     if (!data) return [];
@@ -235,10 +152,7 @@ export function checkBeingAge(note, { index } = {}) {
     const bornRaw = data.born;
     const ageRaw = data.age;
     if (ageRaw === undefined || ageRaw === null || ageRaw === "") return [];
-    if (!index) return [];
-
-    const present = worldInvariants(index).present;
-    const computed = computeAge(bornRaw, present, reckoningContext(index));
+    const computed = computeAge(bornRaw, currentDate, reckoningContext(index));
     if (computed === null) return [];
 
     const authored = parseAgeMagnitude(ageRaw);

package/engine/calendar-notes.mjs

@@ -20,7 +20,7 @@
  * A **world fact** is how long the year is, how the day divides, and how the
  * moon moves. Every people on the world lives under the same ones, so no
  * calendar may restate them: they are read from the package's `place` notes —
- * `data.year` and `data.present` from the world, `data.moon` from the moon —
+ * `data.year` from the world, `data.moon` from the moon —
  * and written by the emitters.
  *
  * A **calendar** is one people's division of those days: the months they name,
@@ -301,7 +301,7 @@ export const CALENDAR_FIELDS = Object.freeze([
  * The `data:` keys a world or a celestial body may write.
  *
  * Four groups, and which note carries which is a fact about the body rather
- * than a convention: a planet states its own size, tilt, year and present; a
+ * than a convention: a planet states its own size, tilt and year; a
  * moon states its own size, orbit and cycle.
  *
  * @type {readonly object[]}
@@ -349,12 +349,6 @@ export const INVARIANT_FIELDS = Object.freeze([
         kind: "number",
         describe: "How many seconds the minute divides into.",
     },
-    {
-        name: "present",
-        shape: "a date",
-        kind: "string",
-        describe: "The day the setting stops and play begins — what an age is computed against.",
-    },
     {
         name: "body.diameterKm",
         shape: "number",
@@ -438,14 +432,13 @@ function keysWritten(note, keys) {
  * note has no year, and every question that depends on one goes unasked.
  *
  * @param {object} [index] - The link index, holding every note in the package.
- * @returns {{year: object|null, present: unknown, moon: object|null,
+ * @returns {{year: object|null, moon: object|null,
  *   body: object|null, moonName: string|null, yearNote: object|null,
  *   moonNote: object|null}} What the package's notes state.
  */
 export function worldInvariants(index) {
     const empty = {
         year: null,
-        present: null,
         moon: null,
         body: null,
         moonName: null,
@@ -459,7 +452,6 @@ export function worldInvariants(index) {
         const data = dataOf(note);
         if (!found.yearNote && data.year && typeof data.year === "object") {
             found.year = data.year;
-            found.present = data.present ?? null;
             found.yearNote = note;
         }
         if (!found.moonNote && data.moon && typeof data.moon === "object") {
@@ -619,9 +611,6 @@ function checkCalendarDayNames(note, daysPerYear) {
  * - a moon with no year is refused, because a cycle measured in days has
  *   nothing to be measured against.
  *
- * `data.present` is read through the parser a note's dates go through, with the
- * corpus in hand, so a present written in an era resolves where it is written.
- *
  * @param {object} note - The note, as the link index hands it over.
  * @param {object} [opts]
  * @param {object} [opts.index] - The link index, holding every note.
@@ -650,17 +639,6 @@ export function checkWorldFacts(note, { index } = {}) {
         return findings;
     }
 
-    if (written.includes("present")) {
-        const { findings: dated } = parseNoteDate(dataOf(note).present, {
-            ...reckoningContext(index),
-            field: "data.present",
-            allowUnknown: false,
-            file: note.file,
-            raw: note.raw,
-            keyPath: ["data", "present"],
-        });
-        findings.push(...dated);
-    }
     if (written.includes("moon") && dataOf(note).moon?.newOn !== undefined) {
         const parsed = parseNoteDate(dataOf(note).moon.newOn, {
             ...reckoningContext(index),

package/engine/compile-corpus.mjs

@@ -61,7 +61,7 @@ import { prepareTreeSqlTables } from "./sql-tables.mjs";
  *   the index refuses is a note the compile must still *report*, exactly as the
  *   compile loop reported it when the loop was the first to see it.
  * @param {import("./content-session.mjs").ContentSession} [opts.session] - Captured context shared with other operations.
- * @returns {Promise<{records: object[], parsed: Map<string, object>, linkIndex: object, sqlTables: Map<string, object[]>|undefined, problems: object[], syntax?: import("./content-session.mjs").ContentSyntax}>} The corpus,
+ * @returns {Promise<{currentDate: string, records: object[], parsed: Map<string, object>, linkIndex: object, sqlTables: Map<string, object[]>|undefined, problems: object[], syntax?: import("./content-session.mjs").ContentSyntax}>} The corpus,
  *   its indexes, and the notes it could not record.
  */
 export async function buildCompileCorpus({
@@ -99,6 +99,7 @@ export async function buildCompileCorpus({
     const sqlOptions = { ...corpusOptions, skipDirectories, parsed };
     const sqlTables = await prepareTreeSqlTables(contentBase, sqlOptions);
     return {
+        currentDate: resolved.currentDate,
         records,
         parsed,
         problems: collected,

package/engine/content-format.yaml

@@ -333,7 +333,6 @@ types:
             - year.hoursPerDay
             - year.minutesPerHour
             - year.secondsPerMinute
-            - present
             - body.diameterKm
             - body.orbitalRadiusKm
             - body.orbit

package/engine/content-index.mjs

@@ -179,7 +179,8 @@ import { isDraftNote } from "./note-vocabulary.mjs";
 // A being's computed `age` — the middle state between an authored override and
 // an unknown one — filled in against the package's own declared present before
 // a record is built, so the index carries it without the note being written to.
-import { applyComputedBeingAge, presentAmongFrontmatters } from "./being-age.mjs";
+import { applyComputedBeingAge } from "./being-age.mjs";
+import { normalizeCurrentDate } from "./current-date.mjs";
 import { reckoningContext } from "./reckoning-markers.mjs";
 import { resolvedDateFields } from "./note-dates.mjs";
 
@@ -1097,6 +1098,7 @@ export function resolveCultures(
  *   asserts that it does not exist. The same holds for a culture conflict: a
  *   reader receives each as a finding, and the emitter throws once, listing
  *   every one.
+ * @param {string} [options.currentDate="720.1"] - Setting-wide neutral current date.
  * @param {(key: string) => ({culture?: unknown}|undefined)} [options.foreignRecord] -
  *   Another package's entry for a canonical address, read for a parent that
  *   package publishes; see {@link resolveCultures}.
@@ -1113,6 +1115,7 @@ export function collectContentIndex(
     contentBase,
     {
         contentPackage,
+        currentDate,
         skipDirectories,
         assetsBase,
         manifest,
@@ -1134,10 +1137,7 @@ export function collectContentIndex(
     // tree to walk and the index is its asset records. The caller decides
     // whether an absent tree is a mistake; by the time the walk is reached it
     // is simply a package with nothing to compile.
-    // Materialised rather than consumed lazily: the present is read from this
-    // same walk before the loop below reads it a second time, and
-    // `walkMarkdownTree` is a generator — a single-use one, exhausted the
-    // moment anything else iterates it first.
+    // Materialize parsed notes once for shared calendar and source context.
     const notes = fs.existsSync(contentBase) ? [...walkMarkdownTree(contentBase, walkOpts)] : [];
     const parsedNotes = [];
     for (const note of notes) {
@@ -1165,10 +1165,8 @@ export function collectContentIndex(
         problems.push(problem);
     }
 
-    // The package's declared present, read once from whichever `place` note in
-    // this same walk states one — the whole tree is already in memory, so no
-    // second read is needed to answer a question about all of it.
-    const present = presentAmongFrontmatters(parsedNotes.map((n) => n.frontmatter));
+    // Every derived age and recurring event uses the same configured date.
+    const present = normalizeCurrentDate(currentDate);
     // Carried on the same context `resolvedDateFields` reads: a recurring
     // event's `next` is computed against this present exactly as a being's
     // `age` already is, above.
@@ -1497,6 +1495,7 @@ export function indexRecordsFor({
     };
     return collectContentIndex(tree, {
         contentPackage: resolved.contentPackage,
+        currentDate: resolved.currentDate,
         addressContext: {
             ...noteAddressContext(resolved),
             declaresAddress: dependencyAddresses(resolved),
@@ -1680,6 +1679,7 @@ export async function prepareContentIndex({ contentBase, config, session } = {})
         });
         const index = buildSiteIndex(pages, {
             package: resolved.contentPackage,
+            currentDate: resolved.currentDate,
             records: visible,
             foreignIndex: foreign.index,
             syntax: session?.syntax,

package/engine/content-links.mjs

@@ -444,13 +444,17 @@ export function buildLinkIndex(
         // Code is verbatim, so a `[[…]]` inside a fence, an indented block or an
         // inline span is not a link — the compilers make none of it either.
         for (const [all, rawInner] of matchAllOutsideCode(body, new RegExp(WIKILINK.source, "g"))) {
-            const parsed = readWikilink(rawInner, {
-                package: pkg,
-                system: "note",
-                types,
-                packages,
-                noIndexPackages,
-            });
+            const parsed = readWikilink(
+                rawInner,
+                {
+                    package: pkg,
+                    system: "note",
+                    types,
+                    packages,
+                    noIndexPackages,
+                },
+                all,
+            );
             const target = parsed.target.kind ? parsed.rawTarget : parsed.target;
             const { anchor, rawTarget } = parsed;
             const occurrence = (seen.get(all) ?? 0) + 1;
@@ -459,6 +463,7 @@ export function buildLinkIndex(
             // in the file. A link a table generated is not in the file at all,
             // so the search simply fails and a finding names the file.
             out.push({
+                attributeProblems: parsed.attributes?.problems ?? [],
                 target,
                 rawTarget,
                 anchor,
@@ -962,15 +967,23 @@ export function auditLinks(index) {
 
     const deadAnchors = [];
     for (const note of notes) {
-        for (const { target, rawTarget, anchor, text, occurrence, labelled } of linksOf(note)) {
+        for (const {
+            target,
+            rawTarget,
+            anchor,
+            text,
+            occurrence,
+            labelled,
+            attributeProblems,
+        } of linksOf(note)) {
             if (!anchor || !labelled) continue;
             const local = target ? resolve(target) : note;
             const foreign = !local && target ? manifestHit(target) : null;
             // An unresolved address is reported below. A foreign sheet opens
             // its system document, so only the readable note view names prose
-            // sections. A public note's GM target is an audience refusal below.
+            // sections, including private destinations.
             if (!local) {
-                if (!foreign || (foreign.gm && !isGmNote(note.fm))) continue;
+                if (!foreign) continue;
                 const qualified = readQualifier(
                     target,
                     index.types,
@@ -1016,7 +1029,24 @@ export function auditLinks(index) {
     const unlabelledLinks = [];
     const usedManifest = new Set();
     for (const note of notes) {
-        for (const { target, rawTarget, anchor, text, occurrence, labelled } of linksOf(note)) {
+        for (const {
+            target,
+            rawTarget,
+            anchor,
+            text,
+            occurrence,
+            labelled,
+            attributeProblems,
+        } of linksOf(note)) {
+            if (attributeProblems.length)
+                deadAddresses.push({
+                    note,
+                    target: rawTarget,
+                    text,
+                    occurrence,
+                    reason: "invalid-attributes",
+                    problems: attributeProblems,
+                });
             // The label is required whatever the link part is, an anchor
             // included — so this is tested before the same-page form.
             if (!labelled) {
@@ -1063,9 +1093,6 @@ export function auditLinks(index) {
             }
             const resolved = index.resolveAddress(target);
             if (resolved) {
-                if ((isGmNote(resolved.fm) || resolved.gm) && !isGmNote(note.fm)) {
-                    deadAddresses.push({ ...at, reason: "gm" });
-                }
                 continue;
             }
             // A stub is in the index, so the refusal can name it. Asked before
@@ -1084,10 +1111,6 @@ export function auditLinks(index) {
             // report.
             const manifest = manifestHit(target);
             if (manifest) {
-                if (manifest.gm && !isGmNote(note.fm)) {
-                    deadAddresses.push({ ...at, reason: "gm" });
-                    continue;
-                }
                 usedManifest.add(encodeAddresses(target).toLowerCase());
                 continue;
             }

package/engine/content-spans.mjs

@@ -21,21 +21,47 @@ import { inlineText } from "./name-markup.mjs";
 
 /** Add bracket spans after recognized Markdown links and footnotes.
  * @param {import("markdown-it")} md - Markdown parser to extend.
+ * @param {object} [options] - Surface presentation.
+ * @param {boolean} [options.source] - Emit opaque authored source tokens for buffer preview.
+ * @param {boolean} [options.spoilers] - Add focusable CSS spoiler wrappers (Foundry).
  */
-export function spanMarkdownPlugin(md) {
+export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}) {
+    if (spoilers) {
+        md.renderer.rules.span_open = (tokens, index, options, env, renderer) => {
+            const token = tokens[index];
+            const secret = (token.attrGet("class") ?? "").split(/\s+/).includes("secret");
+            if (secret) {
+                token.attrSet("data-inline-spoiler", "");
+                token.attrSet("tabindex", "0");
+                if (!token.attrGet("title"))
+                    token.attrSet("title", "Spoiler: hover or focus to reveal");
+                if (!token.attrGet("aria-label"))
+                    token.attrSet("aria-label", "Spoiler; focus to reveal");
+            }
+            return renderer.renderToken(tokens, index, options);
+        };
+    }
     md.inline.ruler.after("link", "bracket_span", (state, silent) => {
         const start = state.pos;
         if (
             state.src[start] !== "[" ||
+            // Raw wikilinks are handled before spans render. Refuse their
+            // adjacent closing brackets without parsing every label twice.
+            (state.src[start + 1] === "[" &&
+                state.src[state.src.indexOf("]", start + 2) + 1] === "]") ||
             /@[A-Za-z]+$/.test(state.src.slice(0, start)) ||
-            state.src[start + 1] === "[" ||
             state.src[start + 1] === "^" ||
             state.src[start + 1] === "!" ||
             ["!", "[", "]"].includes(state.src[start - 1])
         )
             return false;
         const end = state.md.helpers.parseLinkLabel(state, start, false);
-        if (end < 0 || ["(", "["].includes(state.src[end + 1])) return false;
+        if (
+            end < 0 ||
+            ["(", "["].includes(state.src[end + 1]) ||
+            (state.src[start + 1] === "[" && state.src[end + 1] !== "{")
+        )
+            return false;
         let finish = end + 1;
         let parsed = { id: "", classes: [], values: {}, problems: [] };
         if (state.src[finish] === "{") {
@@ -69,6 +95,22 @@ export function spanMarkdownPlugin(md) {
             state.pos = finish;
             return true;
         }
+        if (source) {
+            // An incomplete attribute stays opaque through the end of its line.
+            if (state.src[finish] === "{") {
+                const newline = state.src.indexOf("\n", finish);
+                finish = newline < 0 ? state.posMax : newline;
+            }
+            const token = state.push("span_source", "", 0);
+            token.content = state.src.slice(start, finish);
+            token.meta = {
+                text: state.src.slice(start + 1, end),
+                labelEnd: end - start,
+                secret: parsed.classes.includes("secret"),
+            };
+            state.pos = finish;
+            return true;
+        }
         const token = state.push("span_open", "span", 1);
         token.meta = {
             span: true,
@@ -259,10 +301,15 @@ export function renderSpans(source) {
         )
         .sort((a, b) => b.start - a.start)) {
         const attrs = span.attrs.map(([key, value]) => ` ${key}="${escape(value)}"`).join("");
-        markdown =
-            markdown.slice(0, span.start) +
-            `<span${attrs}>${renderSpans(markdown.slice(span.start + 1, span.contentEnd)).markdown}</span>` +
-            markdown.slice(span.end);
+        const inner = renderSpans(markdown.slice(span.start + 1, span.contentEnd)).markdown;
+        const secret = span.attrs.some(
+            ([key, value]) => key === "class" && value.split(/\s+/).includes("secret"),
+        );
+        const content =
+            secret ?
+                `<span${attrs} data-inline-secret><button type="button" class="inline-secret-toggle" aria-label="Show spoiler" aria-expanded="false">Show spoiler</button><span class="inline-secret-content" hidden>${inner}</span></span>`
+            :   `<span${attrs}>${inner}</span>`;
+        markdown = markdown.slice(0, span.start) + content + markdown.slice(span.end);
     }
     return { markdown, errors };
 }

package/engine/current-date.mjs

@@ -0,0 +1,37 @@
+/*
+ * 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.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/** Setting-wide neutral current date, independent of configuration loading. */
+import { parseNoteDate } from "./note-dates.mjs";
+
+/** Default day on the neutral setting timeline. */
+export const DEFAULT_CURRENT_DATE = "720.1";
+
+/**
+ * Validate a quoted neutral date and preserve its authored day digits.
+ * @param {unknown} [value] - Explicit configuration or adapter override.
+ * @returns {string} Validated neutral date; undefined selects the default.
+ * @throws {TypeError} An explicit value is not a valid neutral date string.
+ */
+export function normalizeCurrentDate(value = undefined) {
+    if (value === undefined) return DEFAULT_CURRENT_DATE;
+    if (typeof value !== "string" || !/^-?\d+(?:\.\d+)?(?::\d{6})?$/.test(value.trim()))
+        throw new TypeError('currentDate must be a quoted neutral date: "<year>[.<day>[:HHMMSS]]"');
+    const text = value.trim();
+    const parsed = parseNoteDate(text, { allowUnknown: false });
+    if (!parsed.date || parsed.findings.some((finding) => finding.severity === "error"))
+        throw new TypeError(
+            `currentDate: ${parsed.findings[0]?.message ?? "invalid neutral date"}`,
+        );
+    return text;
+}

package/engine/definition-list.mjs

@@ -0,0 +1,58 @@
+/*
+ * 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.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/** Semantic dictionary rows for HTML definition lists. @module */
+
+/**
+ * Group each term and its definitions without reparsing their Markdown tokens.
+ * Register after markdown-it-deflist; nested blocks and footnotes retain their
+ * document context.
+ * @param {import("markdown-it")} md - An HTML Markdown parser with definition lists.
+ */
+export function dictionaryListPlugin(md) {
+    md.core.ruler.push("dictionary_list_rows", (state) => {
+        const output = [],
+            lists = [];
+        const row = (nesting) => {
+            const token = new state.Token(
+                nesting === 1 ? "dictionary_row_open" : "dictionary_row_close",
+                "div",
+                nesting,
+            );
+            token.block = true;
+            output.push(token);
+        };
+        for (const token of state.tokens) {
+            if (token.type === "dl_open") {
+                if (!(token.attrGet("class") ?? "").split(/\s+/).includes("dictionary"))
+                    token.attrJoin("class", "dictionary");
+                lists.push({ row: false });
+            } else if (token.type === "dt_open" && lists.length) {
+                const list = lists.at(-1);
+                if (list.row) row(-1);
+                row(1);
+                list.row = true;
+            } else if (token.type === "dd_open" && lists.length) {
+                // A loose definition begins with an inline first paragraph.
+                token.block = false;
+            } else if (token.type === "dt_close" && lists.length) {
+                // Inter-tag whitespace would add a word space to the fixed gap.
+                token.block = false;
+            } else if (token.type === "dl_close" && lists.length) {
+                if (lists.pop().row) row(-1);
+            }
+            output.push(token);
+        }
+        state.tokens = output;
+    });
+}