@heroiclands/package-build 23.11.0 → 23.12.1

package/docs/reference/format-details.md

@@ -1822,11 +1822,12 @@ link to the whole public note does not inherit a section's secrecy.
 
 The website renders an inline show/hide spoiler; an omitted GM-only target
 retains its reference as text without a dead link. A published secret section
-retains its link. Foundry renders a visible inline spoiler with a **Secret:**
-label, with access to its destination controlled by private packs and page
-permissions. Books print secret styling and a **Secret:** label, retaining text
-without a link when the GM-only destination is omitted. `.show` bypasses the
-automatic spoiler presentation on each surface; an unavailable destination
+retains its link. Foundry renders a CSS-redacted inline spoiler, revealed on
+hover or keyboard focus, with destination access controlled by private packs
+and page permissions. Books ignore inline `.secret` presentation and print
+references normally, retaining text without a link when the GM-only destination
+is omitted. `.show` bypasses automatic spoiler presentation on the website and
+in Foundry; book references already print normally. An unavailable destination
 still has no link.
 
 An immediately following `.show` attribute explicitly reveals the reference:
@@ -1850,9 +1851,13 @@ infoboxes, code, comments and embeds are outside this check.
 
 A name is explicit: a `[Name]{.name}` bracket span or an authored link label.
 Use typed `.name` spans for unwritten subjects and ordinary wikilinks for
-indexed subjects, including private ones. Introduce another subject with its
-full canonical name at its first prose use; use plain text for the note's own
-subject and for later mentions and aliases.
+indexed subjects, including private ones. Mark or link another subject at its
+first prose use, and use plain text for the note's own subject and for later
+mentions and aliases. A wikilink identifies its note, so its label is whatever
+reads naturally in the sentence: `[[place-vedyara|Vedyara]]` for a note whose
+full name is _Vedyara Region_, and a lowercase article mid-sentence
+(`[[place-southwall|the Southern Wall]]`). A `.name` span has no note behind
+it, so it carries the full name.
 Plain prose is not searched for names. Wikilinks, ordinary Markdown links and
 reference links all supply names; a resolved empty wikilink label uses the
 note's full name. Images, code, footnote markers and bare autolinks without
@@ -1866,9 +1871,10 @@ authored labels supply none.
    anchors. Other labels use their whole text as their identity: different
    labels linking to one page are separate names, and a label is not
    automatically an alias of its destination.
-3. Introduce the full name before a short form or declared alias.
-   Possessives and regular plurals count as uses; other indexed forms can be
-   declared aliases.
+3. A `.name` span or an ordinary Markdown link introduces the full name
+   before a short form or declared alias. A resolved wikilink introduces its
+   note under any label. Possessives and regular plurals count as uses; other
+   indexed forms can be declared aliases.
 
 Bold is emphasis. A whole bold span exactly matching an indexed full name or
 alias receives one advisory to mark or link the name. It supplies no name
@@ -2667,7 +2673,13 @@ local to a note; rendered markers are sequential numbers. A Foundry page
 collects its referenced footnotes in a Footnotes section at the bottom of that
 JournalEntryPage, while a book places them at the bottom of the page of
 reference. A term followed by `: definition` lines creates a definition list.
-See the [authoring examples](../authoring/links-and-markup.md#footnotes-and-definition-lists).
+After a blank line, indent continuation paragraphs and blocks by four spaces
+to keep them in the same definition; indent a code block's opening fence,
+contents and closing fence. Another `:` starts a separate definition for the
+same term. See the [authoring examples](../authoring/links-and-markup.md#footnotes-and-definition-lists). Definition lists use dictionary hanging indents: bold, nonwrapping terms,
+normal definitions, a 150px shared column (100px at browser widths up to 600px),
+a `.75em` term gap and `.5em` entry spacing. A long term pushes only the first
+definition line beyond the shared column; continuation lines return to it.
 
 ```
 # Heading {#id .class1 .class2 attr="value"}
@@ -3528,11 +3540,13 @@ The exact `.secret` class marks the enclosed text as an inline spoiler:
 ```
 
 The website provides an inline show/hide button and preserves interactive links
-inside the revealed content. Foundry prints a visible inline `secret` span
-with a **Secret:** label; the span does not withhold its text from players.
-The book prints the text with secret styling and a **Secret:** label.
-Inline emphasis and combined `.name` classification survive rendering. Published HTML retains the text, so opening
-the spoiler or inspecting the source reveals it.
+inside the revealed content. Foundry renders a focusable, CSS-redacted inline
+span that reveals its text and nested content on hover or keyboard focus.
+Native Foundry secret sections retain their own controls. Books ignore `.secret`
+on inline spans, preserving their text, emphasis, links, anchors and `.name`
+bold styling. Secret sections and `:::secret` fences keep their visible labelled
+boxes. Published HTML retains the text, so opening the spoiler or inspecting the
+source reveals it.
 
 This span has no effect on a destination's audience. Ordinary wikilinks derive
 spoilers from their resolved destinations; `.show` bypasses that automatic
@@ -4555,7 +4569,7 @@ three fields are built around.
   unrecorded. Both spellings of `died` mean dead.
 - **`age` is optional and is an override.** Written, it wins over anything the
   dates say. Unwritten beside a dated `born`, it is the age that follows from
-  the date and the package's declared present — see below. Unwritten beside
+  the date and the configured current date — see below. Unwritten beside
   `born: unknown` or an absent `born`, the age is unknown.
 
 Most people in a setting do not know their own birth date, so an age beside
@@ -4568,22 +4582,15 @@ read it.
 
 #### The age a dated `born` computes to
 
-A package states the day its setting stops on `data.present`, on its own
-`world` or `celestial` `place` note — see _What a body states about itself_
-under `type: place`. Against that date, a being with a dated `born` and no
-authored `age` compiles the age it implies: the two dates compared, not the
-two years subtracted, so a birthday that falls later in the year than the
-present counts one less than the years alone would say. A package that
-declares no present computes no age and says nothing about it — the same
-silence a package with no calendar mechanism meets.
-
-**An authored `age` beside a dated `born` is expected to agree with what the
-date computes.** Where it does not, `package-build lint` raises a warning
-naming both values, so a stale age left behind after a `born` was corrected
-does not go unnoticed. The warning is silent beside `born: unknown` or an
-absent `born` — there is nothing there to disagree with — and silent wherever
-the package declares no present, for the same reason no age is computed at
-all.
+The root configuration's `currentDate` states the setting's neutral current
+date, defaulting to `"720.1"`. A being with a dated `born` and no authored `age`
+compiles the age implied by those dates. A birthday later in the year counts one
+less than the difference between the years. A year-only birth date uses day one.
+Unknown and absent birth dates supply no computed age.
+
+An authored `age` beside a dated `born` is expected to agree with the configured
+current date. `package-build lint` warns when the values disagree. Authored ages,
+including zero and estimates such as `~34`, remain unchanged in built output.
 
 Use `born:` for a being's birth date.
 
@@ -6989,7 +6996,6 @@ level with no background prints nothing.
 | `year.hoursPerDay`                | `number`                                                                         | How many hours the day divides into                                                                       |
 | `year.minutesPerHour`             | `number`                                                                         | How many minutes the hour divides into                                                                    |
 | `year.secondsPerMinute`           | `number`                                                                         | How many seconds the minute divides into                                                                  |
-| `present`                         | `date`                                                                           | The day the setting stops and play begins                                                                 |
 | `body.diameterKm`                 | `number`                                                                         | The body's diameter, in kilometres                                                                        |
 | `body.orbitalRadiusKm`            | `number`                                                                         | How far it orbits from the body it circles, in kilometres                                                 |
 | `body.orbit`                      | `string`                                                                         | The orbit's shape — `circular` means the cycle never varies                                               |
@@ -7021,7 +7027,6 @@ about the world's year.
 data:
   world: { equatorialCircumferenceKm: 40000, surfaceGravityG: 1.0, axialTiltDegrees: 23.5 }
   year: { days: 365, hoursPerDay: 24, minutesPerHour: 60, secondsPerMinute: 60 }
-  present: 720
 
 # its moon — a note of its own, because a moon is a body and not a property
 data:
@@ -7039,14 +7044,13 @@ else wrote down.
 can say which one a calendar divides; a `moon` with no `year` anywhere is
 refused, because a cycle counted in days has no year to be measured against.
 
-**`present` is the day an age is computed against**, written in the grammar a
-note's dates are written in, so a setting whose present is best said in an era
-says it that way.
+The root configuration's `currentDate` supplies the neutral date used for age
+calculations throughout the setting. Its default is `"720.1"`.
 
 **`world.axialTiltDegrees`, the circumference, the gravity, the moon's diameter
 and its orbital radius are read by nobody.** They are there so a reader knows
 what kind of world this is. What the build consumes is the year, the day's
-divisions, the present, the moon's cycle and epoch, and whether its orbit is
+divisions, the moon's cycle and epoch, and whether its orbit is
 circular and inclined.
 
 #### What a settlement's market supports

package/docs/reference/note-types.md

@@ -885,7 +885,6 @@ Lore records in-world knowledge. A `culture` describes a people; a `custom` desc
 | `data.year.hoursPerDay`                | number                                                            | How many hours the day divides into.                                                                                                                                                |
 | `data.year.minutesPerHour`             | number                                                            | How many minutes the hour divides into.                                                                                                                                             |
 | `data.year.secondsPerMinute`           | number                                                            | How many seconds the minute divides into.                                                                                                                                           |
-| `data.present`                         | a date                                                            | The day the setting stops and play begins — what an age is computed against.                                                                                                        |
 | `data.body.diameterKm`                 | number                                                            | The body's diameter, in kilometres.                                                                                                                                                 |
 | `data.body.orbitalRadiusKm`            | number                                                            | How far the body orbits from the one it circles, in kilometres.                                                                                                                     |
 | `data.body.orbit`                      | string                                                            | The orbit's shape — `circular` means the cycle never varies.                                                                                                                        |

package/docs/reference/theme-pages.md

@@ -515,4 +515,4 @@ A row is a linked title and, when the page carries one, its description.
 
 ## Alerts
 
-The content renderer emits an `aside` with `alert` and `alert-note`, `alert-tip`, `alert-important`, `alert-warning` classes. The `alert-title` header contains a Font Awesome icon and the type's label. Shared styles supply a colored left rule, colored header and ordinary readable body; alerts do not use `details` and never start collapsed. Authored identifiers, additional classes and named attributes belong to the entire aside. Secret blocks retain their separate expandable presentation on the website.
+The content renderer emits an `aside` with `alert` and `alert-note`, `alert-tip`, `alert-important`, `alert-warning` classes. The `alert-title` header contains a Font Awesome icon and the type's label. Shared styles supply a colored left rule, colored header, tinted background and readable body text. The website uses the dark palette; Foundry selects a light or dark palette from its color scheme. Alerts do not use `details` and never start collapsed. Authored identifiers, additional classes and named attributes belong to the entire aside. Secret blocks retain their separate expandable presentation on the website.

package/docs/source-preview.md

@@ -0,0 +1,172 @@
+---
+shortcode: source-preview
+name: { full: "Source preview and Gitea renderer" }
+type: doc
+subType: reference
+---
+
+# Source preview and Gitea renderer
+
+Preview renders only the supplied Markdown buffer. It works with ordinary
+Markdown, optional YAML frontmatter, and local Heroic Lands extensions, without
+configuration, a content tree, dependency caches, a content index or Pandoc.
+
+```sh
+package-build-preview < note.md > preview.html
+package-build-preview --dark < note.md > preview.html
+package-build-preview --current-date 740.1 < note.md > preview.html
+package-build-preview --css > preview.css
+```
+
+The command writes an HTML fragment by default. Include `preview.css` in the
+hosting page to apply the syntax colors, panels and tinted alerts. Light mode
+is the default; `--dark` is explicit and independent of browser preferences.
+`--css` emits both scoped palettes and does not read stdin. `--help` lists the
+options. Unsupported arguments exit 1. Findings go to stderr; success exits 0,
+and render errors exit 1. A partial preview may accompany error findings.
+
+Wikilinks, image and portrait links retain their complete source: blue brackets,
+purple addresses, bold foreground labels and grey attributes. Entire spans are bold, including their visible brackets and attributes.
+Definition-list terms are bold and definitions use normal text. SQL and pagelist fences remain grey source;
+they never execute. Calendar expressions, dependent expressions, references and
+maps remain green source. Local expressions can evaluate against authored
+frontmatter. Missing ages are calculated from neutral birth dates and the root
+`currentDate` setting, defaulting to `"720.1"`, as for other package outputs.
+Authored ages, including `0`, take precedence. Unknown or calendar-dependent
+birth dates omit the age row; `{{data.age}}` is empty when unavailable. Generated sections,
+related pages and See also are absent. Preview performs no publication or link
+checks. Alerts render with their icons, titles, Markdown bodies and tinted
+backgrounds, including nested alerts. Secret blocks are closed disclosure
+spoilers. An authored `.secret` heading hides its section through the next
+heading at the same or a higher level, while retaining its anchor. Secret spans
+redact their label until hover or keyboard focus; explicit `.secret` wikilink
+and image attributes similarly redact their inner source. The authored outer
+brackets and attributes remain visible. This uses scoped CSS and a focusable
+wrapper, with no preview JavaScript required.
+
+Applications import `renderPreview` and `previewStyles` from
+`@heroiclands/package-build/preview`. The HTML wrapper has `hl-preview` and
+exactly one mode class: `hl-preview-light` or `hl-preview-dark`. See the
+[API reference](api.md) for the function contract.
+
+## Current date
+
+Declare the setting-wide date as a quoted root configuration value:
+
+```yaml
+currentDate: "720.1"
+```
+
+The standalone command discovers the nearest `package-build.config.yaml`,
+`.yml` or `.mjs` from its working directory. YAML reads only `currentDate`; it
+requires no other package fields, content or index. MJS executes its trusted
+configuration module. Missing configuration or an absent setting uses `"720.1"`.
+Invalid explicit values fail with a configuration diagnostic. Use
+`--current-date DATE` to override discovery for one invocation. Dates must use
+neutral `<year>[.<day>[:HHMMSS]]` syntax; named-calendar dates are refused.
+
+The pure `renderPreview` API accepts `currentDate` and never reads configuration.
+Hosts can opt into `await readPreviewCurrentDate(projectRoot)` to read the root
+setting before rendering. Repeated calls observe configuration edits. This is
+the same root setting used by compilation, website output and other toolchain
+consumers; there is no separate preview date setting.
+
+## Gitea installation
+
+Install Node 24 or newer and this package in the Gitea runtime, including the
+container image when applicable. The examples assume installation at
+`/opt/heroiclands/node_modules/@heroiclands/package-build` and a usable Node
+executable on Gitea's PATH. Pin the package version in the installation's
+`package.json` and lockfile.
+
+Copy [the complete renderer configuration](../assets/preview/gitea.ini) into
+`app.ini`. It replaces whole-file rendering for the listed Markdown extensions;
+it does not replace Gitea's issue-comment or pull-request discussion renderer.
+The renderer section must appear before its sanitizer sections. Its command
+reads stdin and emits HTML; it needs no repository checkout. Change the absolute
+command path to match the installation. Gitea normally uses the shared default
+`"720.1"` because it receives no repository checkout. To select the deployment's
+setting-wide date explicitly, use:
+
+```ini
+RENDER_COMMAND = /opt/heroiclands/node_modules/.bin/package-build-preview --current-date 740.1
+```
+
+Keep this override aligned with the setting's root configuration. Without an
+override, run Gitea from a directory with no package-build configuration so
+unrelated local configuration cannot select the date.
+
+The supplied configuration keeps sanitization enabled and disables Gitea's
+post-processing so preserved source and literal links remain intact. It permits
+only the preview's class families on the elements that need them, plus the SVG
+attributes needed for alert icons. Gitea's default SVG rules retain `viewBox`,
+`width`, `height`, `aria-hidden`, path `d` and `fill-rule`; the extra rules retain
+`fill="currentColor"` and circle coordinates. The wrapper mode class, syntax
+span classes, fence classes and infobox wrapper must survive sanitization for
+styling to work. Source is escaped text, so no additional source-data attributes
+are required. The `secretFocus` rule retains only `tabindex="0"` on span
+wrappers so keyboard users can reveal redacted source labels. Do not enable
+arbitrary styles, scripts or data-URI images.
+
+Install the stylesheet and optional theme adapter beneath the Gitea custom
+path. Here `custom` means the actual instance's `CustomPath`:
+
+```sh
+mkdir -p custom/public/assets/css custom/public/assets/js
+/opt/heroiclands/node_modules/.bin/package-build-preview --css > custom/public/assets/css/heroiclands-preview.css
+cp /opt/heroiclands/node_modules/@heroiclands/package-build/assets/preview/gitea-theme.js custom/public/assets/js/heroiclands-preview.js
+```
+
+Add to `custom/templates/custom/header.tmpl`, preserving existing content:
+
+```html
+<link rel="stylesheet" href="{{AppSubUrl}}/assets/css/heroiclands-preview.css" />
+<script defer src="{{AppSubUrl}}/assets/js/heroiclands-preview.js"></script>
+```
+
+Restart Gitea after configuration/template changes. Regenerate the CSS asset
+when updating the package. These are administrator installation instructions;
+package-build does not deploy or change the server configuration.
+
+## Gitea theme selection
+
+The external renderer runs on the server and cannot see a reader's active
+theme. The installed browser adapter reads Gitea's root CSS variable
+`--is-dark-theme`, selecting dark for `true` and light for `false`. It follows
+`data-theme` changes, stylesheet loads and newly inserted preview nodes. It
+changes only `.markup.markdown .hl-preview` mode classes; the surrounding Gitea
+interface keeps its own colors. A custom theme that omits the variable retains
+the initial renderer mode.
+
+Without the browser adapter, use the default command for fixed light rendering,
+or append `--dark` to `RENDER_COMMAND` for fixed dark rendering. Explicit CLI
+mode never changes itself. Theme adaptation happens only when the administrator
+installs the separate browser script.
+
+## Sanitizer validation
+
+[The validation harness](../assets/preview/check-sanitizer.go) applies the
+shipped INI rules using the actual `bluemonday` sanitizer and the relevant
+Gitea SVG defaults. It requires a Go toolchain and a temporary module with
+`github.com/microcosm-cc/bluemonday` at the version used by the target Gitea
+release. Run it against generated preview HTML:
+
+```sh
+go run check-sanitizer.go /path/to/gitea.ini < preview.html > sanitized.html
+```
+
+Check both light and dark fixtures containing all four alert types, a custom
+title, nesting, wikilinks and attributes, SQL/pagelist fences, infoboxes, poetry
+and footnotes. All wrapper/token classes and icon shapes should remain, while
+injected scripts and event-handler attributes should disappear. This replay
+checks the sanitizer primitives; also inspect the result in the actual Gitea
+version before deployment, since defaults can vary between releases.
+
+Configuration and installation follow Gitea's
+[external renderer documentation](https://docs.gitea.com/administration/external-renderers/).
+The relevant implementation contracts are its
+[command adapter](https://github.com/go-gitea/gitea/blob/main/modules/markup/external/external.go),
+[sanitizer defaults](https://github.com/go-gitea/gitea/blob/main/modules/markup/sanitizer_default.go),
+[renderer settings](https://github.com/go-gitea/gitea/blob/main/modules/setting/markup.go),
+[root theme attribute](https://github.com/go-gitea/gitea/blob/main/templates/base/head.tmpl),
+and [theme scheme variable](https://github.com/go-gitea/gitea/blob/main/web_src/css/themes/theme-gitea-dark.css).

package/engine/base-compiler.mjs

@@ -103,10 +103,11 @@ import { packForType } from "./ids.mjs";
 import { resolveNoteId } from "./note-ids.mjs";
 import { carriesSystemBlock } from "./system-block.mjs";
 import { checkAuthoredSystemData, checkEmittedSystemData } from "./schema-check.mjs";
-// A being's computed `age`, filled in against the package's own declared
-// present before this pass reads `data:` for anything else — see
+// A being's computed `age`, filled in against the configured setting
+// current date before this pass reads `data:` for anything else — see
 // `engine/being-age.mjs`.
-import { applyComputedBeingAge, presentAmongRecords } from "./being-age.mjs";
+import { applyComputedBeingAge } from "./being-age.mjs";
+import { normalizeCurrentDate } from "./current-date.mjs";
 import { reckoningContext } from "./reckoning-markers.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
 import { annotateAssetReferences, assetReferenceLookup } from "./asset-references.mjs";
@@ -632,10 +633,8 @@ export class BasePackCompiler {
         if (this.constructor.convertsWikilinks) {
             this.sqlTables = this.corpus.sqlTables;
         }
-        // The package's declared present, read once from the same corpus — so
-        // a being's computed `age` reaches every compiled document, not only
-        // the content index.
-        this.worldPresent = presentAmongRecords(this.corpus.records);
+        // Use the compile corpus's setting date.
+        this.currentDate = normalizeCurrentDate(this.corpus.currentDate);
         this.unresolvedLinks = 0;
     }
 
@@ -1277,7 +1276,7 @@ export class BasePackCompiler {
                 stats.skippedOther++;
                 continue;
             }
-            applyComputedBeingAge(fm, this.worldPresent, dates);
+            applyComputedBeingAge(fm, this.currentDate, dates);
             // `package:` is refused before `selects`, so a note is answered
             // whichever pass would have claimed it: a note's package is the
             // repository's configured one, so declaring it restates a

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);