@heroiclands/package-build 22.21.0 → 22.22.0

package/engine/infobox-render.mjs

@@ -36,7 +36,7 @@
 
 import { encodeAddresses } from "./address-values.mjs";
 import { sectionHolds } from "./infobox.mjs";
-import { escapeTypst, escapeTypstString } from "./pdf-render.mjs";
+import { absolutePageUrl, escapeTypst, escapeTypstString } from "./pdf-render.mjs";
 
 /**
  * How many cells an attribute grid packs into a row.
@@ -226,16 +226,22 @@ export function sectionHasContent(section) {
  * reference, so the link works on paper as a cross-reference and in a PDF
  * viewer as a jump. Everything else is set as its own words.
  *
+ * A panel's rows address pages the same way prose does, so a page the book does
+ * not print is set as the absolute URL a reader can follow — see
+ * {@link module:engine/pdf-render.absolutePageUrl}.
+ *
  * @param {object} value - A `link` value.
  * @param {Map<string, string>} links - Address slug → the book's anchor.
  * @param {(anchor: string) => string} labelFor - The anchor's Typst label.
+ * @param {string} [site] - The absolute address this book's pages are served at.
  * @returns {string} Typst markup.
  */
-export function linkToTypst(value, links, labelFor) {
+export function linkToTypst(value, links, labelFor, site) {
     const text = escapeTypst(value?.text ?? "");
     const anchor = value?.address ? links?.get(encodeAddresses(value.address)) : undefined;
     if (anchor) return `#link(<${labelFor(anchor)}>)[${text}]`;
-    if (value?.url) return `#link("${escapeTypstString(value.url)}")[${text}]`;
+    if (value?.url)
+        return `#link("${escapeTypstString(absolutePageUrl(value.url, site))}")[${text}]`;
     return text;
 }
 
@@ -375,7 +381,13 @@ export function infoboxTypstPreamble() {
             "fill: infobox-rule)[#upper(t)]; v(0.20em) }",
         '#let infobox-head(t) = { v(0.40em); text(size: 7.6pt, weight: "bold", ' +
             "tracking: 1.3pt, fill: infobox-rule)[#upper(t)]; v(0.16em) }",
+        // One definition-list style across the three surfaces: the term right
+        // against a fixed column so every term in the panel shares one edge,
+        // and space below the row rather than rows run together. A page has one
+        // width, so the stacked state the screen surfaces fall back to has
+        // nothing to answer here and is not drawn.
         "#let infobox-row(k, v) = grid(columns: (2.05cm, 1fr), column-gutter: 4pt, " +
+            "inset: (bottom: 2pt), align: (right + top, left + top), " +
             "text(size: 7pt, tracking: 0.5pt, fill: infobox-faint)[#upper(k)], text(size: 8pt)[#v])",
         "#let infobox-cell(lab, val) = align(center)[" +
             "#text(size: 7pt, tracking: 0.6pt, fill: infobox-faint)[#lab]#h(2.5pt)" +

package/engine/infobox.mjs

@@ -121,7 +121,13 @@ import { subtypeRow } from "./document-subtypes.mjs";
 import { authoredKey } from "./system-block.mjs";
 import { formatDateInCalendar, formatNoteDate, parseNoteDate } from "./note-dates.mjs";
 import { displayBeingHeight, displayBeingWeight } from "./being-measurements.mjs";
-import { officeAnchor, officeRoster, readStandings, standingPhrase } from "./standings.mjs";
+import {
+    officeAnchor,
+    officeRoster,
+    rankAnchor,
+    readStandings,
+    standingPhrase,
+} from "./standings.mjs";
 
 /**
  * How a section arranges what it holds.
@@ -327,7 +333,8 @@ export const NOTE_FIELD_PRESENTATION = Object.freeze({
     }),
     "being.appearance.complexion": Object.freeze({
         group: "appearance",
-        phrase: (v) => `${humanizeValue(v)} complexion`,
+        whole: true,
+        phrase: (v) => `${humanizedList(v)} complexion`,
     }),
     "being.appearance.extra_features": Object.freeze({ group: "appearance" }),
 });
@@ -469,6 +476,24 @@ export function humanizeValue(value) {
         .trim();
 }
 
+/**
+ * Several enumerated values as one clause — `weathered, ruddy and scarred`.
+ *
+ * A field that admits one value or a list of them reads as a single phrase, so
+ * the noun it qualifies is said once rather than once per value. Internal: the
+ * phrase that wants it is declared in this module.
+ *
+ * @param {unknown} value - One value, or a list of them.
+ * @returns {string} The text.
+ */
+function humanizedList(value) {
+    const parts = (Array.isArray(value) ? value : [value])
+        .filter((entry) => entry !== undefined && entry !== null && entry !== "")
+        .map((entry) => humanizeValue(entry));
+    if (parts.length < 2) return parts[0] ?? "";
+    return `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}`;
+}
+
 /**
  * A value as a row shows it.
  *
@@ -633,6 +658,43 @@ function rosterRows(raw) {
     return rows;
 }
 
+/**
+ * A ladder of named ranks, one row each, ordered by the level a body confers.
+ *
+ * The **title is the label and its description is the value**, the same
+ * convention {@link rosterRows} draws a body's offices with, so a reader
+ * meets the two lists the same way. A rung's optional `lore` — already
+ * resolved to an Address by the time this runs — reads alongside the
+ * description rather than replacing it, since the description is what the
+ * rung itself states and the lore is a pointer to more.
+ *
+ * @param {unknown} raw - The authored `governance.ranks` list.
+ * @param {(ref: unknown, hint?: object) => object|undefined} resolve - The
+ *   medium's resolver.
+ * @returns {object[]|null} One row per rung, in ascending level, or `null`
+ *   where the value is not a list of them.
+ */
+function rankRows(raw, resolve) {
+    if (!Array.isArray(raw)) return null;
+    const rungs = raw
+        .filter((rung) => isMapping(rung) && hasValue(rung.title))
+        .toSorted((a, b) => Number(a.level ?? 0) - Number(b.level ?? 0));
+    const rows = [];
+    for (const rung of rungs) {
+        const anchor = rankAnchor(String(rung.title));
+        const description =
+            hasValue(rung.description) ? String(rung.description) : String(rung.title);
+        const lore = hasValue(rung.lore) ? linkValue(rung.lore, resolve, { type: "lore" }) : null;
+        rows.push({
+            ...(anchor ? { id: anchor } : {}),
+            label: String(rung.title),
+            kind: "text",
+            value: lore?.text ? `${description} (Lore: ${lore.text})` : description,
+        });
+    }
+    return rows;
+}
+
 /** Expand structured references using the existing linked-row shape. */
 function structuredRows(field, raw, resolve, label, fm) {
     if (field.standings) return standingRows(field, raw, resolve, label);
@@ -640,9 +702,20 @@ function structuredRows(field, raw, resolve, label, fm) {
         const roster = rosterRows(raw);
         if (roster) return roster;
     }
-    if (Array.isArray(raw) && raw.some(isMapping)) {
-        const links = raw
-            .filter((entry) => isMapping(entry) && hasValue(entry.to))
+    if (field.ranks) {
+        const ranks = rankRows(raw, resolve);
+        if (ranks) return ranks;
+    }
+    // A relationship entry — `{to, ...}` — is a mapping that is not itself an
+    // Address: an authored plain list of addresses normalises to a list of
+    // Address tuples, which `isMapping` also reports true for, and treating
+    // one as a relationship keyed off a `to` it never carries is what emptied
+    // `lore`, `parents`, `domains` and `economy` silently.
+    const relations =
+        Array.isArray(raw) ? raw.filter((entry) => isMapping(entry) && !isAddressTuple(entry)) : [];
+    if (relations.length) {
+        const links = relations
+            .filter((entry) => hasValue(entry.to))
             .map((entry) => {
                 const link = linkValue(entry.to, resolve, { type: field.ref ?? "place" });
                 const details = Object.entries(entry)
@@ -666,7 +739,7 @@ function structuredRows(field, raw, resolve, label, fm) {
                 const address = parseAddress(
                     target,
                     {
-                        package: fm.package ?? "local",
+                        package: "local",
                         system: "note",
                         types: new Set(field.accepts),
                     },
@@ -789,7 +862,7 @@ function noteBox(
     const rows = [];
     /** @type {Set<string>} */
     const shown = new Set();
-    const name = fm?.name?.full ?? fm?.title;
+    const name = fm?.name?.full;
     if (hasValue(name)) rows.push({ label: "Name", kind: "text", value: String(name) });
     if (Array.isArray(fm?.name?.aliases) && fm.name.aliases.length) {
         rows.push({ label: "Aliases", kind: "list", value: fm.name.aliases });
@@ -857,7 +930,9 @@ function noteBox(
                 label: GROUP_LABELS[overlay.group] ?? humanizeFieldName(overlay.group),
                 entries: [],
             };
-            const parts = Array.isArray(raw) ? raw.filter(hasValue) : [raw];
+            // A `whole` phrase reads the value entire, so several values compose
+            // into one clause rather than repeating the noun once each.
+            const parts = overlay.whole || !Array.isArray(raw) ? [raw] : raw.filter(hasValue);
             for (const part of parts) {
                 group.entries.push(overlay.phrase ? overlay.phrase(part) : humanizeValue(part));
             }

package/engine/journals.mjs

@@ -71,6 +71,14 @@ import { journalHasContent } from "./note-state.mjs";
 import { draftNoticeFor } from "./draft-notice.mjs";
 import { scanCaptions } from "./content-captions.mjs";
 import { separateFootnotes } from "./content-footnotes.mjs";
+import { WITHHELD_CLASS, pageOpenings } from "./heading-attributes.mjs";
+
+/**
+ * `CONST.DOCUMENT_OWNERSHIP_LEVELS.NONE` — the default ownership a withheld
+ * page states. A GM reads every document whatever it says; everyone else reads
+ * this one not at all.
+ */
+const WITHHELD_OWNERSHIP = 0;
 
 /**
  * Splits a markdown body into pages by top-level H1 headings. Fenced
@@ -78,7 +86,8 @@ import { separateFootnotes } from "./content-footnotes.mjs";
  * a split. Content before the first H1 (if non-empty) becomes a leading
  * page. Each H1 yields a page whose name is the heading
  * text (with any `{#anchor-id}` suffix stripped out and surfaced as
- * `anchorSlug`).
+ * `anchorSlug`). The classes the heading declares come along as `classes`, so
+ * a surface that honours one has it without reading the suffix again.
  *
  * `leadName` names that leading page. A journal note's is "Introduction",
  * because it introduces the pages that follow. An item doc's is the item — a
@@ -89,7 +98,7 @@ import { separateFootnotes } from "./content-footnotes.mjs";
  * @param {string} body - Markdown body to split.
  * @param {string} [leadName] - Name of the page before the first heading.
  * @returns {Array<{name: string, anchorSlug: string|null, level: number,
- *   markdown: string}>} Pages in document order.
+ *   classes: string[], markdown: string}>} Pages in document order.
  */
 export function splitPages(body, leadName = "Introduction") {
     const { markdown, definitions } = separateFootnotes(body);
@@ -101,6 +110,7 @@ export function splitPages(body, leadName = "Introduction") {
             .filter((caption) => /^\s*#{1,6}\s/.test(lines[caption.blockStart] ?? ""))
             .map((caption) => caption.blockStart),
     );
+    const openings = pageOpenings(markdown);
     const pages = [];
     const beforeFirstH1 = [];
     let current = null;
@@ -113,6 +123,7 @@ export function splitPages(body, leadName = "Introduction") {
             name: current.name,
             anchorSlug: current.anchorSlug,
             level: current.level,
+            classes: current.classes,
             markdown: current.lines.join("\n").trim(),
         });
         current = null;
@@ -128,11 +139,13 @@ export function splitPages(body, leadName = "Introduction") {
         // An H1 starts a page, as does any heading carrying an `{#slug}`
         // anchor: a Foundry UUID can only address a page, so a linkable
         // section has to be one.
-        const headingMatch =
-            !inCodeBlock && !inSecret ? line.match(/^\s*(#{1,6})\s+(.+?)\s*#*\s*$/) : null;
-        const rawHeading = headingMatch?.[2]?.trim();
-        const anchorMatch = rawHeading?.match(/^(.*?)\s*\{#([^}]+)\}\s*$/);
-        const startsPage = headingMatch && (headingMatch[1].length === 1 || anchorMatch);
+        // {@link module:engine/heading-attributes.parseHeadingLine} is the one
+        // reading of that rule — `scanBlocks` and `scanCaptions` refuse such a
+        // heading written where it cannot become a page, from the same
+        // function, so none of them can disagree about what starts one. The
+        // lines it claims here are collected by `pageOpenings`, which also
+        // skips a fence and a named block.
+        const opening = openings.get(lineIndex);
         const caption = !inCodeBlock && !inSecret ? captionStarts.get(lineIndex) : null;
         if (caption) {
             closeCurrent();
@@ -140,16 +153,18 @@ export function splitPages(body, leadName = "Introduction") {
                 name: caption.label,
                 anchorSlug: caption.id,
                 level: 1,
+                classes: [],
                 lines: [line],
             };
             continue;
         }
-        if (startsPage && !captionedHeadings.has(lineIndex)) {
+        if (opening && !captionedHeadings.has(lineIndex)) {
             closeCurrent();
             current = {
-                name: (anchorMatch ? anchorMatch[1] : rawHeading).trim(),
-                anchorSlug: anchorMatch?.[2]?.trim() || null,
-                level: headingMatch[1].length,
+                name: opening.text,
+                anchorSlug: opening.id || null,
+                level: opening.level,
+                classes: opening.classes,
                 lines: [],
             };
             continue;
@@ -169,6 +184,7 @@ export function splitPages(body, leadName = "Introduction") {
             name: leadName,
             anchorSlug: null,
             level: 1,
+            classes: [],
             markdown: intro,
         });
     }
@@ -273,10 +289,14 @@ export function journalPageId(entryId, page) {
  * @param {Array<object>} rawPages - From {@link splitPages}.
  * @param {string} entryId - The owning JournalEntry's `_id`.
  * @param {string} noteName - The note, for error messages.
+ * A page whose heading carries `.secret` is given to the GM alone, by the one
+ * ownership value Foundry reads as "nobody but a GM". Every other page states
+ * no ownership and inherits the journal's.
+ *
  * @returns {Array<{_id: string, name: string, type: string,
  *   title: {show: boolean, level: number},
- *   text: {format: number, content: string}, _key: string}>} The page
- *   documents, in order.
+ *   text: {format: number, content: string}, _key: string,
+ *   ownership?: {default: number}}>} The page documents, in order.
  * @throws {Error} When the note has no content at all, or repeats an anchor.
  */
 export function buildPages(rawPages, entryId, noteName, captions) {
@@ -296,6 +316,7 @@ export function buildPages(rawPages, entryId, noteName, captions) {
     }
     return rawPages.map((page) => {
         const pageId = journalPageId(entryId, page);
+        const withheld = (page.classes ?? []).includes(WITHHELD_CLASS);
         return {
             _id: pageId,
             name: page.name,
@@ -308,6 +329,7 @@ export function buildPages(rawPages, entryId, noteName, captions) {
                         renderFoundryMarkdown(page.markdown, captions, footnoteNumbers, pageId)
                     :   "",
             },
+            ...(withheld ? { ownership: { default: WITHHELD_OWNERSHIP } } : {}),
             _key: `!journal.pages!${entryId}.${pageId}`,
         };
     });
@@ -329,7 +351,6 @@ export function buildPages(rawPages, entryId, noteName, captions) {
  * @param {string} [params.leadName] - Name for the page before the first
  *   heading; see {@link splitPages}.
  * @param {string|null} [params.folder] - The folder id, or `null`.
- * @param {object} [params.flags] - Document flags.
  * @param {object} [params.stats] - The `_stats` block to stamp. Passed by the
  *   caller because it is a property of the *pack* being written, not of the
  *   entry: a module may ship the same content for two systems, and each pack's
@@ -352,7 +373,6 @@ export function buildJournalEntry({
     markdown,
     leadName,
     folder = null,
-    flags,
     stats = defaultStats(),
     infoboxes = [],
     notice = "",
@@ -379,7 +399,7 @@ export function buildJournalEntry({
         folder,
         sort: 0,
         ownership: { default: 0 },
-        flags: flags || {},
+        flags: {},
         _id: id,
         _stats: stats,
         _key: `!journal!${id}`,
@@ -546,7 +566,6 @@ export class Journals extends BasePackCompiler {
             // "Introduction" — see {@link splitPages}.
             leadName: ownsDoc ? name : undefined,
             folder,
-            flags: fm.flags,
             stats: this.stats,
         });
     }

package/engine/macros.mjs

@@ -272,7 +272,7 @@ export function buildMacroEntry(fm, { command, folder = null, stats = defaultSta
         folder,
         sort: 0,
         ownership: { default: 0 },
-        flags: fm.flags || {},
+        flags: {},
         _id: id,
         _stats: stats,
         _key: `!macros!${id}`,

package/engine/markdown-expressions.mjs

@@ -7,8 +7,182 @@ import { matchAllOutsideCode, replaceOutsideCode } from "./code-fences.mjs";
 import { formatDateInCalendar, parseNoteDate } from "./note-dates.mjs";
 import { numberWords, numberDigits } from "./number-words.mjs";
 
-// Hugo shortcodes begin `{{<` or `{{%` and stay in the source for Hugo.
-const EXPRESSION = /(?<![\\{])\{\{(?![{<%])([^{}\n]+)\}\}(?!\})/g;
+/**
+ * An inline expression, as an author writes one.
+ *
+ * Hugo shortcodes begin `{{<` or `{{%` and stay in the source for Hugo.
+ *
+ * Exported because a renderer that meets one has met a body this pass never ran
+ * over, and has to be able to say so.
+ *
+ * @type {RegExp}
+ */
+export const EXPRESSION = /(?<![\\{])\{\{(?![{<%])([^{}\n]+)\}\}(?!\})/g;
+
+/**
+ * Every helper an expression may call, with the parameters it takes.
+ *
+ * **This is the one list.** The engine registers from it and the authoring
+ * document is checked against it, so a helper added here is a helper the
+ * document must describe, and a helper the document describes but the engine
+ * does not register fails the same test.
+ *
+ * `make` receives the render's context — the prepared SQL results and the date
+ * rules — and returns the function Handlebars calls. A helper that needs
+ * neither ignores it.
+ */
+const HELPERS = Object.freeze([
+    Object.freeze({
+        name: "eq",
+        params: "a b",
+        summary: 'True when both are the same value. Compares exactly, so 1 and "1" differ.',
+        make: () => (left, right) => left === right,
+    }),
+    Object.freeze({
+        name: "gt",
+        params: "a b",
+        summary: "True when a is greater than b. Both must be finite numbers.",
+        make: () => numericCompare("gt", (a, b) => a > b),
+    }),
+    Object.freeze({
+        name: "gte",
+        params: "a b",
+        summary: "True when a is greater than or equal to b. Both must be finite numbers.",
+        make: () => numericCompare("gte", (a, b) => a >= b),
+    }),
+    Object.freeze({
+        name: "lt",
+        params: "a b",
+        summary: "True when a is less than b. Both must be finite numbers.",
+        make: () => numericCompare("lt", (a, b) => a < b),
+    }),
+    Object.freeze({
+        name: "lte",
+        params: "a b",
+        summary: "True when a is less than or equal to b. Both must be finite numbers.",
+        make: () => numericCompare("lte", (a, b) => a <= b),
+    }),
+    Object.freeze({
+        name: "not",
+        params: "value",
+        summary: "True when the value is false, zero, empty or absent.",
+        make: () => (value) => !value,
+    }),
+    Object.freeze({
+        name: "and",
+        params: "value …",
+        summary: "True when every value given is true. Takes two or more.",
+        make:
+            () =>
+            (...args) =>
+                args.slice(0, -1).every(Boolean),
+    }),
+    Object.freeze({
+        name: "or",
+        params: "value …",
+        summary: "True when any value given is true. Takes two or more.",
+        make:
+            () =>
+            (...args) =>
+                args.slice(0, -1).some(Boolean),
+    }),
+    Object.freeze({
+        name: "words",
+        params: "number",
+        summary:
+            "The number spelled out for running prose — `1200` becomes one thousand two hundred. " +
+            "Whole numbers only; a decimal is a finding, and `digits` takes one.",
+        make: () => (value) => numberWords(value),
+    }),
+    Object.freeze({
+        name: "digits",
+        params: "number",
+        summary:
+            "The number as a grouped numeral — `1200` becomes 1,200, and a fractional part is kept.",
+        make: () => (value) => numberDigits(value),
+    }),
+    Object.freeze({
+        name: "sql",
+        params: '"query"',
+        summary:
+            "The single value a query returns, for use inside a sentence. The query is a quoted " +
+            "string, the same SQL a table fence takes.",
+        make:
+            ({ sqlResults }) =>
+            (query) => {
+                if (typeof query !== "string" || !query.trim())
+                    throw new TypeError("sql needs a nonempty query string");
+                const result = sqlResults?.get(query);
+                if (!result)
+                    throw new RangeError(`SQL expression has no prepared result: ${query}`);
+                if (result.error) throw new RangeError(`SQL expression failed: ${result.error}`);
+                return result.value;
+            },
+    }),
+    Object.freeze({
+        name: "dateformat",
+        params: 'calendar date ["format"]',
+        summary:
+            "A date written in a calendar. The calendar is an Address or its shortcode, the date " +
+            "is the value a note carries, and the optional third argument names an output pattern.",
+        make:
+            ({ dates }) =>
+            (calendar, authored, formatOrOptions) => {
+                if (
+                    !(typeof calendar === "string" || isAddressTuple(calendar)) ||
+                    !["string", "number"].includes(typeof authored)
+                )
+                    throw new TypeError("dateformat needs a calendar Address and a date");
+                const parsed = parseNoteDate(authored, { ...dates, allowUnknown: false });
+                const error = parsed.findings.find((item) => item.severity === "error");
+                if (error || !parsed.date)
+                    throw new RangeError(error?.message ?? "date does not resolve");
+                const printable = formatDateInCalendar(
+                    parsed.date,
+                    isAddressTuple(calendar) ? renderAddress(calendar) : calendar,
+                    dates,
+                    typeof formatOrOptions === "string" ? formatOrOptions : undefined,
+                );
+                if (!printable)
+                    throw new RangeError(`date cannot be printed in calendar ${calendar}`);
+                return printable.prose ?? printable.text;
+            },
+    }),
+]);
+
+/**
+ * A comparison of two numbers, which refuses anything else.
+ *
+ * Four helpers differ only in the comparison, and a value that is not a finite
+ * number is a finding rather than a silent `false`.
+ *
+ * @param {string} name - The helper's name, for the message.
+ * @param {(a: number, b: number) => boolean} compare - The comparison.
+ * @returns {(left: unknown, right: unknown) => boolean} The helper.
+ */
+function numericCompare(name, compare) {
+    return (left, right) => {
+        const finite = (value) =>
+            typeof value === "bigint" || (typeof value === "number" && Number.isFinite(value));
+        if (!finite(left) || !finite(right))
+            throw new TypeError(`${name} needs two finite numbers`);
+        return compare(left, right);
+    };
+}
+
+/**
+ * Each helper's parameters and what it does, keyed by name.
+ *
+ * The authoring document describes this surface, and a test holds the two
+ * together. A consumer reads it to list what an expression may call.
+ *
+ * @type {Readonly<Record<string, Readonly<{params: string, summary: string}>>>}
+ */
+export const EXPRESSION_HELPERS = Object.freeze(
+    Object.fromEntries(
+        HELPERS.map(({ name, params, summary }) => [name, Object.freeze({ params, summary })]),
+    ),
+);
 
 /** Find SQL helper calls, including calls nested inside Boolean expressions. */
 export function sqlQueriesInMarkdown(body, fm = {}) {
@@ -47,57 +221,8 @@ export function renderMarkdownExpressions(
 ) {
     const findings = [];
     const engine = Handlebars.create();
-    const numeric = (name, left, right) => {
-        if (
-            !["number", "bigint"].includes(typeof left) ||
-            !["number", "bigint"].includes(typeof right) ||
-            (typeof left === "number" && !Number.isFinite(left)) ||
-            (typeof right === "number" && !Number.isFinite(right))
-        )
-            throw new TypeError(`${name} needs two finite numbers`);
-    };
-    for (const [name, compare] of Object.entries({
-        gt: (a, b) => a > b,
-        gte: (a, b) => a >= b,
-        lt: (a, b) => a < b,
-        lte: (a, b) => a <= b,
-    }))
-        engine.registerHelper(name, (left, right) => {
-            numeric(name, left, right);
-            return compare(left, right);
-        });
-    engine.registerHelper("eq", (left, right) => left === right);
-    engine.registerHelper("not", (value) => !value);
-    engine.registerHelper("and", (...args) => args.slice(0, -1).every(Boolean));
-    engine.registerHelper("or", (...args) => args.slice(0, -1).some(Boolean));
-    engine.registerHelper("words", (value) => numberWords(value));
-    engine.registerHelper("digits", (value) => numberDigits(value));
-    engine.registerHelper("sql", (query) => {
-        if (typeof query !== "string" || !query.trim())
-            throw new TypeError("sql needs a nonempty query string");
-        const result = sqlResults?.get(query);
-        if (!result) throw new RangeError(`SQL expression has no prepared result: ${query}`);
-        if (result.error) throw new RangeError(`SQL expression failed: ${result.error}`);
-        return result.value;
-    });
-    engine.registerHelper("dateformat", (calendar, authored, formatOrOptions) => {
-        if (
-            !(typeof calendar === "string" || isAddressTuple(calendar)) ||
-            !["string", "number"].includes(typeof authored)
-        )
-            throw new TypeError("dateformat needs a calendar Address and a date");
-        const parsed = parseNoteDate(authored, { ...dates, allowUnknown: false });
-        const error = parsed.findings.find((item) => item.severity === "error");
-        if (error || !parsed.date) throw new RangeError(error?.message ?? "date does not resolve");
-        const printable = formatDateInCalendar(
-            parsed.date,
-            isAddressTuple(calendar) ? renderAddress(calendar) : calendar,
-            dates,
-            typeof formatOrOptions === "string" ? formatOrOptions : undefined,
-        );
-        if (!printable) throw new RangeError(`date cannot be printed in calendar ${calendar}`);
-        return printable.prose ?? printable.text;
-    });
+    for (const helper of HELPERS)
+        engine.registerHelper(helper.name, helper.make({ sqlResults, dates }));
     const markdown = replaceOutsideCode(body, EXPRESSION, (source, _inside, offset) => {
         try {
             return engine.compile(source, { strict: true })(fm ?? {});

package/engine/note-dates.mjs

@@ -117,6 +117,39 @@ function unknownRecord() {
     };
 }
 
+/**
+ * Whether a number-valued date may have lost a trailing zero off its day.
+ *
+ * YAML reads an unquoted `<year>.<day>` as a float, and a float carries no
+ * trailing zero: `born: 667.130` and `born: 667.13` both arrive as `667.13`.
+ * The authored digits are unrecoverable by then, so the question a reader needs
+ * answered is whether a longer day was *possible* — and it was exactly when the
+ * value with one more zero on the end still names a day the world's year holds.
+ *
+ * One zero settles it. A second only makes the day ten times longer again, so a
+ * value whose single-zero expansion already falls outside the year has no
+ * reading but the one it was handed.
+ *
+ * **The world's year length is what makes the question answerable**, so a tree
+ * whose notes declare none gets no claim either way — the same rule the upper
+ * bound on a day follows. Refusing every float there would red a whole corpus
+ * over a test nothing could evaluate.
+ *
+ * @param {number} value - The authored value, as YAML parsed it.
+ * @param {number|undefined} daysPerYear - The world's year length.
+ * @returns {boolean} True when the authored day is ambiguous.
+ */
+function dayCouldHaveLostAZero(value, daysPerYear) {
+    if (Number.isInteger(value)) return false;
+    const fraction = String(Math.abs(value)).split(".")[1] ?? "";
+    // An exponent-form string carries no day at all.
+    if (!/^\d+$/.test(fraction)) return false;
+    const tenfold = Number(`${fraction}0`);
+    if (!Number.isSafeInteger(tenfold)) return false;
+    if (!Number.isSafeInteger(daysPerYear) || daysPerYear < 1) return false;
+    return tenfold <= daysPerYear;
+}
+
 /**
  * Parse one authored date.
  *
@@ -194,6 +227,22 @@ export function parseNoteDate(value, options) {
         return { date: null, findings };
     };
 
+    // An unquoted `<year>.<day>` reaches here as a float, and YAML has already
+    // dropped a trailing zero off the day: `667.13` and `667.130` arrive as one
+    // value, so nothing downstream can tell day 13 from day 130. Refused where
+    // the lost zero would still name a day inside the world's year, and read as
+    // written where no such day exists — `675.281` cannot have been `675.2810`.
+    if (typeof value === "number" && dayCouldHaveLostAZero(value, daysPerYear)) {
+        const grown = `${text}0`;
+        return refuse(
+            `${subject} is a number, and a day's trailing zero is lost before a date ` +
+                `is read — \`${text}\` and \`${grown}\` reach this check as one value. ` +
+                `Quote a canonical date that states a day, \`"${text}"\` or ` +
+                `\`"${grown}"\`, so the digits the note states are the digits the ` +
+                `build reads`,
+        );
+    }
+
     const resolveEra = (parsed, reckoning, label) => {
         if (parsed.year < 1) return refuse(`${subject} needs a positive year in ${label}`);
         if (!Number.isSafeInteger(daysPerYear) || daysPerYear < 1)