@heroiclands/package-build 22.8.0 → 22.9.1

package/engine/calendars.mjs

@@ -52,14 +52,23 @@
  * and off by one on the other, which is invisible in any list that does not
  * span it.
  *
- * ## The month structure is the package's, and an absent bound checks nothing
+ * ## The month structure is the calendar's, and an absent list bounds nothing
  *
- * An era moves where year 1 sits; it does not divide the year differently. So
- * the subdivision is declared once for the package, in `calendar.months` and
- * `calendar.monthDays`, and a package that declares neither is bounded below
- * and not above — a toolchain that invented twelve Gregorian months would
- * refuse `667/2/30`, which is an ordinary date in a year of twelve thirty-day
- * months.
+ * An era moves where year 1 sits; it does not divide the year differently. The
+ * division belongs to the calendar, which is a note declaring an **ordered
+ * list** of months, each with a name and a day count. Position in the list is
+ * position in the year, so a five-day month sits wherever its people put it and
+ * needs no rule of its own.
+ *
+ * A date is bounded by the calendar it is written in, and a calendar whose list
+ * nobody has written down bounds nothing — a toolchain that invented twelve
+ * Gregorian months would refuse `667/2/30`, an ordinary date in a year of
+ * twelve thirty-day months.
+ *
+ * ## The lunar phase takes a floored modulo, not JavaScript's
+ *
+ * `%` takes the dividend's sign, so a day before the epoch yields `-7` where
+ * the phase is 23. {@link lunarPhase} is the one place that is written.
  *
  * @module
  */
@@ -118,15 +127,107 @@ export function dateSortKey(year, month, day) {
 }
 
 /**
- * The bounds a package states for a month, or `null` where it states none.
+ * One month of a calendar, as the note declares it.
  *
- * Separate from the check that reads it so a caller can ask what a package
- * declares without phrasing a finding about it.
+ * @typedef {object} CalendarMonth
+ * @property {string} name - What the month is called.
+ * @property {string} [abbreviation] - A short form, where the note gives one.
+ * @property {number} days - How many days it holds.
+ */
+
+/**
+ * The months a calendar keeps, or `null` where it declares none.
+ *
+ * Separate from the check that reads it so a caller can ask what a calendar
+ * divides its year into without phrasing a finding about it. An empty list
+ * reads as no list: a calendar that declares nothing and one that declares
+ * nothing in a pair of brackets divide the year identically.
  *
- * @param {{months?: number|null, monthDays?: number|null}} [calendar] - The
- *   resolved `calendar:` block.
- * @returns {{months: number|null, monthDays: number|null}} What it declares.
+ * @param {{months?: readonly CalendarMonth[]|null}} [calendar] - The calendar
+ *   the date is written in, as its note declares it.
+ * @returns {{months: readonly CalendarMonth[]|null}} What it divides the year
+ *   into.
  */
 export function calendarStructure(calendar) {
-    return { months: calendar?.months ?? null, monthDays: calendar?.monthDays ?? null };
+    const written = calendar?.months;
+    if (!Array.isArray(written) || written.length === 0) return { months: null };
+    return { months: written };
+}
+
+/**
+ * How long one month of a calendar is, or `null` where the calendar is silent.
+ *
+ * @param {{months?: readonly CalendarMonth[]|null}} [calendar] - The calendar.
+ * @param {number} month - The month, numbered from 1.
+ * @returns {number|null} Its length in days, or `null`.
+ */
+export function daysInMonth(calendar, month) {
+    const { months } = calendarStructure(calendar);
+    if (!months || month < 1 || month > months.length) return null;
+    const days = months[month - 1]?.days;
+    return typeof days === "number" ? days : null;
+}
+
+/**
+ * How many days the months add up to.
+ *
+ * The number a calendar's list claims the year is. Whether that is the year the
+ * world keeps is a question about the world, and is asked elsewhere.
+ *
+ * @param {readonly CalendarMonth[]} months - The ordered month list.
+ * @returns {number} The sum of their day counts.
+ */
+export function daysInYear(months) {
+    return months.reduce((sum, month) => sum + (Number(month?.days) || 0), 0);
+}
+
+/**
+ * The day of the year each month opens on, in order, numbered from 1.
+ *
+ * The sum read as a sequence rather than as a total. Two lists holding the same
+ * numbers in a different order sum alike and open their months on different
+ * days, which is the error a total cannot see.
+ *
+ * @param {readonly CalendarMonth[]} months - The ordered month list.
+ * @returns {number[]} One entry per month: the day of the year it begins on.
+ */
+export function monthStarts(months) {
+    const starts = [];
+    let day = 1;
+    for (const month of months) {
+        starts.push(day);
+        day += Number(month?.days) || 0;
+    }
+    return starts;
+}
+
+/**
+ * Which day of the year a written month and day land on, numbered from 1.
+ *
+ * @param {readonly CalendarMonth[]} months - The ordered month list.
+ * @param {number} month - The month, numbered from 1.
+ * @param {number} day - The day within it, numbered from 1.
+ * @returns {number} The day of the year.
+ */
+export function dayOfYear(months, month, day) {
+    return monthStarts(months)[month - 1] + day - 1;
+}
+
+/**
+ * How far into its cycle a moon is on a given day.
+ *
+ * **Floored, not truncated.** JavaScript's `%` takes the dividend's sign, so a
+ * day seven before the epoch yields `-7` where the phase is 23 — a value that
+ * is right on one side of the epoch and wrong on the other, which is invisible
+ * in any list that does not span it.
+ *
+ * @param {number} dayNumber - The day, on whatever continuous day count the
+ *   caller keeps.
+ * @param {number} epochDay - The day of that same count on which the moon was
+ *   new.
+ * @param {number} cycle - The cycle's length in days.
+ * @returns {number} Days into the cycle, `0` to `cycle - 1`.
+ */
+export function lunarPhase(dayNumber, epochDay, cycle) {
+    return (((dayNumber - epochDay) % cycle) + cycle) % cycle;
 }

package/engine/content-index.mjs

@@ -137,6 +137,10 @@ import {
     sortKeysDeep,
 } from "./index-records.mjs";
 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";
 
 export {
     authoredFrontmatter,
@@ -606,10 +610,20 @@ 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.
-    const notes = fs.existsSync(contentBase) ? walkMarkdownTree(contentBase, walkOpts) : [];
+    // 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.
+    const notes = fs.existsSync(contentBase) ? [...walkMarkdownTree(contentBase, walkOpts)] : [];
+
+    // 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(notes.map((n) => n.frontmatter));
 
     for (const { frontmatter, body, bodyLine, absPath } of notes) {
         const fm = frontmatter ?? {};
+        applyComputedBeingAge(fm, present);
         // The id the note's document is filed under, resolved before
         // the record is built so the index publishes the address *and* the id
         // that address derives.

package/engine/index.mjs

@@ -130,6 +130,12 @@ export * as calendars from "./calendars.mjs";
 /** A note's dates: one authored string, one grammar, one record shape. */
 export * as noteDates from "./note-dates.mjs";
 
+/** Calendars as notes: what one may declare, and the definition emitted from it. */
+export * as calendarNotes from "./calendar-notes.mjs";
+
+/** A being's `age`, absent beside a dated `born`: the age the date computes to. */
+export * as beingAge from "./being-age.mjs";
+
 /** The one normalisation this build makes: prose to a URL-safe token. */
 export * as contentSlug from "./content-slug.mjs";
 

package/engine/infobox.mjs

@@ -291,6 +291,12 @@ export const NOTE_FIELD_PRESENTATION = Object.freeze({
     // than as six rows of numbers, exactly as the book prototype sets them.
     // Qualified by type, because `weight` is also what a coin weighs.
     "being.age": Object.freeze({ group: "appearance", phrase: (v) => `Age ${v}` }),
+    // The `~` estimate's numeric companion — beside `age` in the index for a
+    // machine to sort or filter on, not a second row for a reader who already
+    // meets it inside the appearance clause.
+    "being.ageYears": Object.freeze({
+        withheld: "the `age` row's own machinery, not a second fact about the subject",
+    }),
     "being.height": Object.freeze({ group: "appearance", phrase: heightPhrase }),
     "being.weight": Object.freeze({ group: "appearance", phrase: weightPhrase }),
     "being.frame": Object.freeze({ group: "appearance", phrase: (v) => `${v} frame` }),

package/engine/note-dates.mjs

@@ -27,9 +27,9 @@
  *   `-1` sits immediately before `1`.
  * - `YYYY` — required.
  * - `MM`, `DD` — optional, in that order.
- * - `ERA` — an affiliation's address plus `.<era shortcode>`, in the four
- *   address forms {@link ERA_QUALIFIER_PATTERN} admits. Omitted, the date sits
- *   on the canonical axis and is attributed to nobody.
+ * - `ERA` — a calendar's address plus `.<era shortcode>`, in the four address
+ *   forms {@link ERA_QUALIFIER_PATTERN} admits. Omitted, the date sits on the
+ *   canonical axis and is attributed to nobody.
  *
  * **Precision falls out of how much is written.** `-984` is a year, `689/6` a
  * month, `689/6/19` a day. There is no precision vocabulary, so there is
@@ -98,7 +98,7 @@
  */
 
 import { ADDRESS_SEGMENT_PATTERN } from "./address-charset.mjs";
-import { calendarStructure, canonicalYear, dateSortKey } from "./calendars.mjs";
+import { calendarStructure, canonicalYear, dateSortKey, daysInMonth } from "./calendars.mjs";
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
 
 /**
@@ -120,7 +120,7 @@ const ERA = `(?:${SEGMENT}-){0,3}${SEGMENT}\\.${SEGMENT}`;
 /**
  * What a date's trailing token may look like.
  *
- * An affiliation's address followed by `.<era shortcode>`. The `{0,3}`
+ * A calendar note's address followed by `.<era shortcode>`. The `{0,3}`
  * repetition is the four address forms exactly — bare `shortcode`,
  * `type-shortcode`, `system-type-shortcode` and
  * `package-system-type-shortcode` — so the hyphen separates an address's
@@ -182,9 +182,10 @@ function unknownRecord() {
  * @param {unknown} value - The authored value. A number is what YAML hands
  *   back for a bare year, so it is accepted and stringified.
  * @param {object} [options]
- * @param {{months?: number|null, monthDays?: number|null}} [options.calendar]
- *   The resolved `calendar:` block, whose `months` and `monthDays` bound a
- *   written month and day. An absent bound is not applied.
+ * @param {{months?: readonly object[]|null}} [options.calendar] - The calendar
+ *   the value is written in, as its note declares it. Its ordered month list
+ *   bounds a written month and a written day, the day against the length of
+ *   the month it names. A calendar that declares no list bounds nothing.
  * @param {string} [options.field] - The key that carried it, named in every
  *   message. Omitted, a message names the value alone.
  * @param {boolean} [options.allowUnknown=true] - Whether `"unknown"` is a
@@ -246,7 +247,7 @@ export function parseNoteDate(value, options) {
         if (MALFORMED_ERA_PATTERN.test(trimmed)) {
             return refuse(
                 `${subject} — an era is written ` +
-                    `\`<affiliation shortcode>.<era shortcode>\`, lowercase letters ` +
+                    `\`<calendar shortcode>.<era shortcode>\`, lowercase letters ` +
                     `and digits only`,
             );
         }
@@ -256,14 +257,14 @@ export function parseNoteDate(value, options) {
             // the rule rather than guessing a concrete replacement.
             return refuse(
                 `${subject} names no era — a reckoning is written ` +
-                    `\`<affiliation shortcode>.<era shortcode>\`: a year before ` +
+                    `\`<calendar shortcode>.<era shortcode>\`: a year before ` +
                     `an era's epoch is written negative, and a year after it ` +
                     `simply drops the token`,
             );
         }
         return refuse(
             `${subject} is not a date — write ` +
-                `\`[~][-]YYYY[/MM[/DD]] [<affiliation shortcode>.<era shortcode>]\`: ` +
+                `\`[~][-]YYYY[/MM[/DD]] [<calendar shortcode>.<era shortcode>]\`: ` +
                 `a year, negative where it falls before the epoch it is counted ` +
                 `from, optionally a month and a day, and an era where the date is a ` +
                 `reckoning somebody kept`,
@@ -285,26 +286,31 @@ export function parseNoteDate(value, options) {
         );
     }
 
-    const { months, monthDays } = calendarStructure(calendar);
+    const { months } = calendarStructure(calendar);
     if (month !== null && month < 1) {
         return refuse(`${subject} writes month ${month}, and a month is numbered from 1`);
     }
-    // An upper bound is checked only where the package states one. Twelve
-    // Gregorian months assumed here would refuse `667/2/30`, which is a correct
-    // date in a year of twelve thirty-day months.
-    if (month !== null && months !== null && month > months) {
+    // An upper bound is checked only where the calendar states its months.
+    // Twelve Gregorian months assumed here would refuse `667/2/30`, which is a
+    // correct date in a year of twelve thirty-day months.
+    if (month !== null && months !== null && month > months.length) {
         return refuse(
-            `${subject} writes month ${month}, and \`calendar.months\` declares a ` +
-                `year of ${months}`,
+            `${subject} writes month ${month}, and the calendar it is written in ` +
+                `keeps ${months.length} months`,
         );
     }
     if (day !== null && day < 1) {
         return refuse(`${subject} writes day ${day}, and a day is numbered from 1`);
     }
-    if (day !== null && monthDays !== null && day > monthDays) {
+    // Per month, because the months differ: a five-day month sits in the list
+    // wherever its people put it, and a bound taken from the longest month
+    // would accept a date that calendar has no day for.
+    const length = month !== null ? daysInMonth(calendar, month) : null;
+    if (day !== null && length !== null && day > length) {
+        const named = months?.[month - 1]?.name;
         return refuse(
-            `${subject} writes day ${day}, and \`calendar.monthDays\` declares a ` +
-                `month of ${monthDays}`,
+            `${subject} writes day ${day}, and ${named ? `${named}` : `month ${month}`} ` +
+                `is ${length} days long`,
         );
     }
 

package/engine/note-vocabulary.mjs

@@ -85,6 +85,16 @@ import { currentType } from "./ids.mjs";
 // What a place is next to and reachable from — the two relation lists and
 // the checks that hold them to their closed sets and to each other.
 import { checkBorders, checkRoutes } from "./place-relations.mjs";
+import {
+    CALENDAR_FIELDS,
+    INVARIANT_FIELDS,
+    checkCalendarNote,
+    checkWorldFacts,
+} from "./calendar-notes.mjs";
+// Whether a being's authored `age` disagrees with what `born` and the
+// package's declared present compute — the closed `data:` container's own
+// question, asked the way `checkPlace` and `checkCalendarNote` are.
+import { checkBeingAge } from "./being-age.mjs";
 import { checkHeld } from "./holdings.mjs";
 import { checkCitedPopulations, checkPopulation } from "./populations.mjs";
 // What trade a settlement supports — the scale and the check that holds a
@@ -306,6 +316,22 @@ const CHARGES = Object.freeze([
     { name: "charges.max", ...NUM, describe: "Most charges it can hold; unset means no maximum." },
 ]);
 
+/**
+ * Everything `place` asks of a whole note.
+ *
+ * Two questions about one subject, and they are independent: who holds this
+ * land, and — where the note is a body rather than somewhere within one — what
+ * the body states about itself. A type declares one whole-note check, so the
+ * two are composed here rather than either being folded into the other.
+ *
+ * @param {object} note - The note.
+ * @param {object} [opts] - The lint's options, passed through unchanged.
+ * @returns {object[]} Findings from both.
+ */
+function checkPlace(note, opts) {
+    return [...checkHeld(note, opts), ...checkWorldFacts(note, opts)];
+}
+
 /* --------------------------------------------------------------------- */
 /*  The vocabulary                                                        */
 /* --------------------------------------------------------------------- */
@@ -565,6 +591,9 @@ export const NOTE_VOCABULARY = Object.freeze({
         // lands with. Declared open until it does, because inventing the
         // values here would put a second, weaker answer beside the real one.
         subTypes: null,
+        // Whether an authored `age` disagrees with what `born` and the
+        // package's declared present compute — see `engine/being-age.mjs`.
+        check: checkBeingAge,
         data: Object.freeze([
             TOKEN_ICON,
             TEMPLATE_PRIORITY,
@@ -612,6 +641,13 @@ export const NOTE_VOCABULARY = Object.freeze({
                     "for an estimate. Unstated beside a dated `born` it is computed; unstated " +
                     "beside an unknown or absent `born` the age is unknown.",
             },
+            {
+                name: "ageYears",
+                ...NUM,
+                describe:
+                    "Written by the compiler beside an `age` estimate — the `~` stripped, " +
+                    "the magnitude alone. A note never authors this.",
+            },
             { name: "height", ...NUM, describe: "Height in metres." },
             { name: "weight", ...NUM, describe: "Weight in kilograms." },
             {
@@ -1044,16 +1080,27 @@ export const NOTE_VOCABULARY = Object.freeze({
             "bestiary",
             "gathering",
         ]),
-        // Nothing of its own: a lore note is prose, and what it *is* about is
-        // its subType. The specification declares an empty table for it, and
-        // the authored corpus writes no `data:` key on any of the 180.
-        data: Object.freeze([]),
+        // A lore note is prose, and what it *is* about is its subType — with
+        // one exception. A calendar is a division of the year, and a division
+        // is data; the check scopes the family to the subType that means it,
+        // because `DataFieldSpec` declares the keys a type accepts and not the
+        // subType that may write them.
+        check: checkCalendarNote,
+        data: CALENDAR_FIELDS,
     }),
 
     place: Object.freeze({
         stubbable: true,
-        subTypes: Object.freeze(["world", "region", "settlement", "site", "structure", "feature"]),
-        check: checkHeld,
+        subTypes: Object.freeze([
+            "world",
+            "region",
+            "settlement",
+            "site",
+            "structure",
+            "feature",
+            "celestial",
+        ]),
+        check: checkPlace,
         data: Object.freeze([
             {
                 name: "demonym",
@@ -1104,6 +1151,10 @@ export const NOTE_VOCABULARY = Object.freeze({
                     "Journeys from this place's centre — where the destination lies, how " +
                     "it is travelled, and about how many days it takes.",
             },
+            // What a body states about itself: its size, its year, its moon.
+            // Legal on a `world` or a `celestial` and nowhere else, which the
+            // type's own check is what enforces.
+            ...INVARIANT_FIELDS,
         ]),
     }),
 

package/engine/site-build.mjs

@@ -72,6 +72,9 @@ import { routerFor } from "./pack-router.mjs";
 import { searchableFrontmatter } from "./note-package.mjs";
 // The corpus, from the one pass that derives it.
 import { indexRecordsFor } from "./content-index.mjs";
+// A being's computed `age` — see `engine/being-age.mjs`. `pdf-build.mjs`
+// reuses `collectContentPages`'s pages, so wiring it here reaches the book too.
+import { applyComputedBeingAge, presentAmongRecords } from "./being-age.mjs";
 import { isNoteRecord, noteFile } from "./index-records.mjs";
 // The one statement of what an empty body means, shared with the index.
 import { isStubNote } from "./note-state.mjs";
@@ -166,9 +169,22 @@ export function collectContentPages(contentBase, ctx) {
     const addressFindings = [];
     const fmLinkFindings = [];
 
+    // The package's declared present, read once from the same corpus the site
+    // and the PDF share — see `engine/being-age.mjs`. `pdf-build.mjs` reaches
+    // this through the pages this function returns, so one call covers both.
+    const present = presentAmongRecords(
+        ctx.records ??
+            indexRecordsFor({
+                contentBase,
+                config: ctx.config,
+                skipDirectories: ctx.skipDirectories,
+            }),
+    );
+
     for (const file of siteCorpusFiles(contentBase, ctx)) {
         const note = readNote(file);
         if (!note) continue;
+        applyComputedBeingAge(note.fm, present);
         const { fm, body } = note;
         // The configuration's, never a note's: `package:` is retired, so every
         // note in the tree belongs to the package this repository compiles.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "22.8.0",
+    "version": "22.9.1",
     "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",

package/types/content-config.d.mts

@@ -844,16 +844,6 @@ export type ContentBuildConfig = {
      * each pack followed by its companions.
      */
     packDirectories: readonly string[];
-    /**
-     *                                     How this package's year is divided, and
-     *                                     the date it calls the present. Every
-     *                                     value `null` when none is declared.
-     */
-    calendar: Readonly<{
-        months: number | null;
-        monthDays: number | null;
-        present: string | null;
-    }>;
     /**
      * Passed through
      * frozen, uninterpreted. `{}` when absent.

package/types/engine/base-compiler.d.mts

@@ -378,6 +378,7 @@ export class BasePackCompiler {
     linkIndex: any;
     contentDocs: any;
     sqlTables: any;
+    worldPresent: unknown;
     /**
      * The body {@link BasePackCompiler#buildEntry} receives.
      *

package/types/engine/being-age.d.mts

@@ -0,0 +1,92 @@
+/**
+ * Parse an authored `age` into its estimate mark and its magnitude.
+ *
+ * @param {unknown} raw - The authored value — `34`, `"34"` or `"~34"`.
+ * @returns {{approximate: boolean, value: number}|null} The parts, or `null`
+ *   for a value that does not read as a plain count of years.
+ */
+export function parseAgeMagnitude(raw: unknown): {
+    approximate: boolean;
+    value: number;
+} | null;
+/**
+ * The age two dates imply, in whole years, computed from the dates themselves
+ * rather than from the years alone.
+ *
+ * @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.
+ * @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.
+ */
+export function computeAge(bornRaw: unknown, presentRaw: unknown): number | null;
+/**
+ * Fill in a being's computed `age`, and the numeric companion an estimate
+ * carries beside it — mutating the frontmatter object handed in, never a file
+ * on disk.
+ *
+ * Every caller holds a frontmatter object that was parsed fresh from a note's
+ * text for its own pass — the content index, a compiled document, a rendered
+ * page — and none of those objects round-trips back to the `.md` file. So
+ * patching `data.age` in place here is exactly as safe as reading it, and
+ * reaches every surface that reads `data:` after this runs, with the note
+ * 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.
+ * @returns {void}
+ */
+export function applyComputedBeingAge(fm: object, presentRaw: unknown): void;
+/**
+ * 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: readonly object[] | undefined): unknown;
+/**
+ * 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: readonly (object | null | undefined)[] | undefined): unknown;
+/**
+ * Check a being's authored `age` against what `born` and the package's present
+ * compute.
+ *
+ * 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.
+ *
+ * @param {object} note - The note, as the link index hands it over —
+ *   {@link module:engine/calendar-notes.worldInvariants}'s `index.notes` shape.
+ * @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.
+ * @returns {object[]} Findings — at most one `warning`, naming both values.
+ */
+export function checkBeingAge(note: object, { index }?: {
+    index?: object | undefined;
+}): object[];