@heroiclands/package-build 23.12.4 → 23.12.6

package/docs/reference/note-types.md

@@ -18,7 +18,7 @@ These are the only keys a note writes at its top level, in the order the formatt
 | Key           | Meaning                                                                                   |
 | ------------- | ----------------------------------------------------------------------------------------- |
 | `shortcode`   | The note's own address segment, unique within its type.                                   |
-| `name`        | The display names — a required `full`, and any `aliases`.                                 |
+| `name`        | The display names — a required `full`, and any `aliases` and `sort`.                      |
 | `type`        | What the note is about, which decides its vocabulary and its document.                    |
 | `subType`     | The type's own genre, where it declares one.                                              |
 | `description` | The short page summary.                                                                   |
@@ -32,14 +32,15 @@ These are the only keys a note writes at its top level, in the order the formatt
 
 These fields are accepted by every note type. A field's value can still be irrelevant to a particular output; the build reports that where it can. `data.icon` is not shared: it is listed under each type whose document carries art.
 
-| Field             | Shape                                           | Meaning                                                                                                                       |
-| ----------------- | ----------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
-| `data.seeAlso`    | list of `{ address, gloss? }`                   | Deliberate cross-references in reading order, with optional glosses; shown on the site, in journals and in books.             |
-| `data.id`         | string                                          | A fixed document identity when the derived identity is unsuitable.                                                            |
-| `data.pack`       | string                                          | The shared compendium route, with a system block overriding it.                                                               |
-| `data.packFolder` | an Address, or a map of Addresses keyed by pack | The shared compendium folder Address, with a system block overriding it.                                                      |
-| `data.harnworld`  | `{ realm?, ritual? }`                           | HârnWorld source details shared by every system — `realm` and `ritual`.                                                       |
-| `data.banner`     | an Address                                      | The page's hero image — an `image` address, cut to 1792×768, or `none` to decline a hero image. Reaches no compiled document. |
+| Field             | Shape                                           | Meaning                                                                                                                                                                                    |
+| ----------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `data.seeAlso`    | list of `{ address, gloss? }`                   | Deliberate cross-references in reading order, with optional glosses; shown on the site, in journals and in books.                                                                          |
+| `data.calendar`   | an Address                                      | The calendar this note's dates print in, as a calendar lore note. Absent, the note takes its culture's calendar, then — for a place — its parents', then the configured `defaultCalendar`. |
+| `data.id`         | string                                          | A fixed document identity when the derived identity is unsuitable.                                                                                                                         |
+| `data.pack`       | string                                          | The shared compendium route, with a system block overriding it.                                                                                                                            |
+| `data.packFolder` | an Address, or a map of Addresses keyed by pack | The shared compendium folder Address, with a system block overriding it.                                                                                                                   |
+| `data.harnworld`  | `{ realm?, ritual? }`                           | HârnWorld source details shared by every system — `realm` and `ritual`.                                                                                                                    |
+| `data.banner`     | an Address                                      | The page's hero image — an `image` address, cut to 1792×768, or `none` to decline a hero image. Reaches no compiled document.                                                              |
 
 **Inner keys** — a key a field's value does not declare is an error at its own line and column.
 
@@ -71,7 +72,6 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.gender`                    | string                                         | One of `female`, `male`, `nonbinary`, `none` or `other`. `none` says the being has no gender; an absent field says its gender is unrecorded. See [a being's look](format-details.md#a-beings-look) for what each word means.                                                                                                                                                                                                                                                                                                                                                           |
 | `data.species`                   | an Address                                     | The being's species, as a lore note.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `data.born`                      | string                                         | When the being was born — a date, or `unknown` where the birth is unrecorded. Absent, the being was never born.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `data.calendar`                  | an Address                                     | Calendar that displays this being's dates.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `data.died`                      | string                                         | When the being died — a date, or `unknown` where the death is unrecorded. Absent, the being is alive.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `data.age`                       | string                                         | Age in years, stated only to override what `born` says — `34`, or `~34` for an estimate. Unstated beside a dated `born` it is computed; unstated beside an unknown or absent `born` the age is unknown.                                                                                                                                                                                                                                                                                                                                                                                |
 | `data.ageYears`                  | number                                         | Written by the compiler beside an `age` estimate — the `~` stripped, the magnitude alone. A note never authors this.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
@@ -867,7 +867,6 @@ Lore records in-world knowledge. A `culture` describes a people; a `custom` desc
 | Field                                  | Shape                                                             | Meaning                                                                                                                                                                             |
 | -------------------------------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `data.events`                          | list of event entries                                             | What happened to or at this subject — each entry one dated, attributed event: a founding, a war, a fall, or an occasion that recurs.                                                |
-| `data.calendar`                        | an Address                                                        | Calendar that displays this place's dates.                                                                                                                                          |
 | `data.demonym`                         | string                                                            | What a person from this place is called — a Vylarian.                                                                                                                               |
 | `data.purpose`                         | string                                                            | The reason this settlement, site, or structure exists, selected from its placeCharacter tags.                                                                                       |
 | `data.lore`                            | list of Addresses                                                 | Lore concerning this place — its peoples, its law, its calendar, its history.                                                                                                       |

package/engine/content-format.yaml

@@ -15,7 +15,6 @@ types:
             - gender
             - species
             - born
-            - calendar
             - died
             - age
             - ageYears
@@ -315,7 +314,6 @@ types:
     place:
         data:
             - events
-            - calendar
             - demonym
             - purpose
             - lore

package/engine/content-index.mjs

@@ -86,6 +86,7 @@
  */
 
 import { isAddressSegment } from "./address-charset.mjs";
+import { configFileIn, resolveNoteCalendars } from "./note-calendars.mjs";
 import { cultureInheritance, reportCultureParents } from "./culture-parents.mjs";
 import {
     formatDiagnostic,
@@ -108,8 +109,9 @@ import { analyzeNameSpans } from "./names.mjs";
 import fs from "node:fs";
 import path from "node:path";
 
-import unidecode from "unidecode";
+import { asciiName } from "./name-sort.mjs";
 
+export { asciiName };
 import { loadForeignIndexes, metadataFileName } from "./metadata-index.mjs";
 import { collectAssetRecords } from "./asset-index.mjs";
 import { checkForeignAssetBindings } from "./asset-bindings.mjs";
@@ -161,7 +163,7 @@ import { resolveNoteId } from "./note-ids.mjs";
 // The `package:` refusal, so a note declaring one is reported where it is
 // rather than as a bare abort.
 import { assertNoDeclaredPackage } from "./note-package.mjs";
-import { loadPackConfig } from "./pack-config.mjs";
+import { CONFIG_FILENAMES, loadPackConfig } from "./pack-config.mjs";
 // The record accessors, which live apart so that a module the compilers load
 // can read a record without importing this one and closing a cycle.
 // Re-exported because this is where callers have always addressed them.
@@ -245,44 +247,6 @@ export function noteAddress(frontmatter, contentPackage) {
     };
 }
 
-/**
- * A note's display name reduced to printable 7-bit ASCII.
- *
- * Content names carry the setting's orthography — `Kûrbúl Helm`, `Hârn`,
- * `Kèthîra` — and nobody types them. A reader searching the index, or an editor
- * completing a wikilink, needs a form that matches what a keyboard produces, so
- * the record states one rather than leaving every consumer to invent it (and to
- * invent a *different* one, which is how two searches over the same data come
- * to disagree).
- *
- * **Transliterated, not stripped.** `unidecode` — the same table
- * {@link slugify} already runs, so an ASCII name and a slug can never disagree
- * about a character — carries a letter across rather than deleting it:
- * diacritics fold (`â`→`a`, `è`→`e`), ligatures expand (`æ`→`ae`, `Œ`→`OE`,
- * `ß`→`ss`), the runic letters spell out (`þ`→`th`, `Þ`→`Th`, `ð`→`d`), and
- * even a vulgar fraction becomes readable (`¾`→`3/4`). Deleting them instead
- * would collapse `Kûrbúl` to `Krbl`, which is worse than the original.
- *
- * Anything still outside printable ASCII after that becomes a space, and runs
- * of whitespace collapse — a space rather than nothing, so a character that
- * transliterates away cannot silently weld two words together.
- *
- * The value is emitted even when it equals the name, so a consumer matching on
- * it never has to branch on whether the name happened to be ASCII already.
- *
- * @param {unknown} name - The note's `name.full`.
- * @returns {string|null} The ASCII form, or `null` when there is no name, or
- *   nothing printable survives.
- */
-export function asciiName(name) {
-    if (typeof name !== "string") return null;
-    const folded = unidecode(name)
-        .replace(/[^\x20-\x7E]/g, " ")
-        .replace(/\s+/g, " ")
-        .trim();
-    return folded === "" ? null : folded;
-}
-
 /**
  * A note's `name.aliases` reduced to printable 7-bit ASCII, in order.
  *
@@ -1099,6 +1063,10 @@ export function resolveCultures(
  *   reader receives each as a finding, and the emitter throws once, listing
  *   every one.
  * @param {string} [options.currentDate="720.1"] - Setting-wide neutral current date.
+ * @param {string} [options.defaultCalendar] - The calendar of last resort, a
+ *   calendar note's shortcode; see {@link module:engine/note-calendars}.
+ * @param {string} [options.configFile] - The configuration file, where an
+ *   unknown `defaultCalendar` is reported.
  * @param {(key: string) => ({culture?: unknown}|undefined)} [options.foreignRecord] -
  *   Another package's entry for a canonical address, read for a parent that
  *   package publishes; see {@link resolveCultures}.
@@ -1116,6 +1084,8 @@ export function collectContentIndex(
     {
         contentPackage,
         currentDate,
+        defaultCalendar,
+        configFile,
         skipDirectories,
         assetsBase,
         manifest,
@@ -1271,7 +1241,17 @@ export function collectContentIndex(
 
     // Every note record exists and every Address in it is a tuple, so a parent
     // is found by its canonical address. Before the sort, which reads nothing
-    // the pass writes.
+    // the pass writes. Calendars first: they read the culture a note states,
+    // which the culture pass then replaces with the one it resolves.
+    resolveNoteCalendars(records, {
+        contentPackage,
+        defaultCalendar,
+        configFile,
+        contentBase,
+        foreignRecord,
+        problems,
+        parsed,
+    });
     resolveCultures(records, { contentPackage, contentBase, foreignRecord, problems, parsed });
     const cultureNotes = records
         .filter((record) => isNoteRecord(record) && record.type === "lore")
@@ -1496,6 +1476,8 @@ export function indexRecordsFor({
     return collectContentIndex(tree, {
         contentPackage: resolved.contentPackage,
         currentDate: resolved.currentDate,
+        defaultCalendar: resolved.defaultCalendar ?? undefined,
+        configFile: configFileIn(resolved.rootDir, CONFIG_FILENAMES),
         addressContext: {
             ...noteAddressContext(resolved),
             declaresAddress: dependencyAddresses(resolved),

package/engine/content-links.mjs

@@ -239,6 +239,9 @@ export function buildLinkIndex(
         const body = splitFrontmatter(raw)?.body ?? raw;
         const type = record.type.toLowerCase();
         const note = { file: absPath, rel, fm, body, raw, type };
+        // The calendar the index resolved, which the reckoning context built
+        // over these notes hands to every date printed for this note.
+        if (record.resolvedCalendar) note.resolvedCalendar = record.resolvedCalendar;
         const hierarchyProblems = cultureRecordProblems(record);
         note.inheritedCultureFields = cultureInheritedFields(record);
         if (hierarchyProblems)

package/engine/event-fields.mjs

@@ -23,7 +23,7 @@
  */
 
 import { ownDocumentSystem, parseAddress, readCanonicalKey, renderAddress } from "./address.mjs";
-import { formatNoteDate, parseNoteDate } from "./note-dates.mjs";
+import { formatDateInCalendar, formatNoteDate, parseNoteDate } from "./note-dates.mjs";
 import { NOTE_VOCABULARY } from "./note-vocabulary.mjs";
 
 /** The fields of an event an inline reference may print, in the order a message names them. */
@@ -161,6 +161,29 @@ export function printEventDate(written, date, dates) {
     return printable?.prose ?? printable?.text ?? date.prose ?? date.text ?? String(written);
 }
 
+/**
+ * A date as `dateformat` prints it in a calendar, where one is named and
+ * prints it; otherwise as {@link printEventDate} prints it.
+ *
+ * @param {unknown} written - The date as the event writes it.
+ * @param {object|null} date - The resolved date.
+ * @param {object} [dates] - The reckoning context.
+ * @param {string} [calendar] - The calendar's Address or shortcode.
+ * @returns {string} The printed date; the authored text when nothing resolves.
+ */
+export function printEventDateIn(written, date, dates, calendar) {
+    if (date?.known && calendar) {
+        try {
+            const printable = formatDateInCalendar(date, calendar, dates);
+            const text = printable?.prose ?? printable?.text;
+            if (text) return text;
+        } catch {
+            // A calendar that does not resolve leaves the date in its own era.
+        }
+    }
+    return printEventDate(written, date, dates);
+}
+
 /**
  * One field of one event, as the text a reference prints, or why it cannot.
  *

package/engine/event-rows.mjs

@@ -25,11 +25,27 @@
  * `resolvedDates.events`, position for position with `data.events`, and the
  * sort keys are read from it rather than parsed again here.
  *
+ * **`whenText` and `untilText` are the dates as a reader of the owning note
+ * sees them**: printed as the `dateformat` helper prints a date, in the
+ * calendar the owning note resolves to — see
+ * {@link module:engine/note-calendars} — else in the era the date itself
+ * names. A date that does not resolve keeps its authored text.
+ *
+ * **`whenIn` and `untilIn` are the same dates in every calendar**: a struct
+ * keyed by each calendar note's canonical Address, every calendar the corpus
+ * holds or any note resolves to, so a query reads a date in the calendar it
+ * chooses — `e.whenIn['thalorna-note-lore-commoncal']`. Every row carries every
+ * key; a date a calendar cannot print reads there as it would in `whenText`
+ * with no calendar, and an absent date is `NULL`. The event views select the
+ * key of the page's calendar.
+ *
  * @module
  */
 
 import { ownDocumentSystem, renderAddress } from "./address.mjs";
+import { printEventDateIn } from "./event-fields.mjs";
 import { EVENT_ENTRY_KEYS } from "./note-event-terms.mjs";
+import { calendarAddress } from "./reckoning-markers.mjs";
 
 /** The columns a row carries besides the event's own keys, before them. */
 const IDENTITY_COLUMNS = Object.freeze(["note", "address"]);
@@ -37,11 +53,19 @@ const IDENTITY_COLUMNS = Object.freeze(["note", "address"]);
 /** The sort keys a row carries, after the event's own keys. */
 export const EVENT_SORT_COLUMNS = Object.freeze(["whenSort", "whenYear", "untilSort", "untilYear"]);
 
+/** The printed dates a row carries, after the sort keys. */
+export const EVENT_TEXT_COLUMNS = Object.freeze(["whenText", "untilText"]);
+
+/** The dates a row carries in every calendar, after the printed ones. */
+export const EVENT_CALENDAR_COLUMNS = Object.freeze(["whenIn", "untilIn"]);
+
 /** Every column of the `events` relation, in order. */
 export const EVENT_COLUMNS = Object.freeze([
     ...IDENTITY_COLUMNS,
     ...EVENT_ENTRY_KEYS,
     ...EVENT_SORT_COLUMNS,
+    ...EVENT_TEXT_COLUMNS,
+    ...EVENT_CALENDAR_COLUMNS,
 ]);
 
 /** The keys whose authored value is a date, printed as the text it was written as. */
@@ -84,22 +108,62 @@ function axisKeys(date) {
     };
 }
 
+/**
+ * Every calendar a set of records can print an event's date in: each calendar
+ * note's canonical Address, and every calendar a note resolves to.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records, every
+ *   Address a string.
+ * @returns {string[]} The calendars, sorted.
+ */
+export function eventCalendars(records) {
+    const calendars = new Set();
+    for (const record of records) {
+        const resolved = calendarAddress(record?.resolvedCalendar);
+        if (resolved) calendars.add(resolved);
+        if (
+            record?.type === "lore" &&
+            String(record.subType ?? "").toLowerCase() === "calendar" &&
+            record.package &&
+            record.shortcode &&
+            !record.documents
+        )
+            calendars.add(
+                renderAddress({
+                    package: String(record.package),
+                    system: "note",
+                    type: "lore",
+                    shortcode: String(record.shortcode),
+                }),
+            );
+    }
+    return [...calendars].sort();
+}
+
 /**
  * The `events` rows of a set of index records.
  *
  * @param {Iterable<Record<string, any>>} records - Index records, every
  *   Address a string, already narrowed to the audience being published to.
+ * @param {object} [dates] - The reckoning context the dates are printed in.
+ * @param {readonly string[]} [calendars] - The calendars `whenIn` and
+ *   `untilIn` are keyed by: {@link eventCalendars} of every record of the
+ *   corpus, whatever the audience, so every surface's relation has the same
+ *   keys. Absent, those of `records`.
  * @returns {object[]} One row per event entry, in record then entry order.
  */
-export function eventRows(records) {
+export function eventRows(records, dates, calendars) {
     const rows = [];
-    for (const record of records) {
+    const all = [...records];
+    const keys = calendars ?? eventCalendars(all);
+    for (const record of all) {
         const events = record?.data?.events;
         if (!Array.isArray(events) || !events.length) continue;
         const note = noteAddressOf(record);
         if (!note) continue;
         const resolved =
             Array.isArray(record.resolvedDates?.events) ? record.resolvedDates.events : [];
+        const calendar = calendarAddress(record.resolvedCalendar);
         events.forEach((entry, position) => {
             if (!entry || typeof entry !== "object" || Array.isArray(entry)) return;
             const row = {
@@ -119,6 +183,22 @@ export function eventRows(records) {
             row.whenYear = when.year;
             row.untilSort = until.sort;
             row.untilYear = until.year;
+            for (const key of DATE_KEYS) {
+                const date = resolved[position]?.[key];
+                row[`${key}Text`] =
+                    row[key] === null ? null : printEventDateIn(row[key], date, dates, calendar);
+                row[`${key}In`] =
+                    keys.length ?
+                        Object.fromEntries(
+                            keys.map((each) => [
+                                each,
+                                row[key] === null ?
+                                    null
+                                :   printEventDateIn(row[key], date, dates, each),
+                            ]),
+                        )
+                    :   null;
+            }
             rows.push(row);
         });
     }

package/engine/event-views.mjs

@@ -41,6 +41,7 @@
 
 import { ownDocumentSystem, renderAddress } from "./address.mjs";
 import { authoredSection, sectionHeading } from "./generated-sections.mjs";
+import { calendarAddress } from "./reckoning-markers.mjs";
 
 /** A literal SQL string. */
 const literal = (text) => `'${String(text).replace(/'/g, "''")}'`;
@@ -48,6 +49,16 @@ const literal = (text) => `'${String(text).replace(/'/g, "''")}'`;
 /** A list of SQL string literals, for an `IN (…)`. */
 const literals = (texts) => texts.map(literal).join(", ");
 
+/**
+ * The `When` column of a view on a page whose dates print in `calendar`: the
+ * event's date in that calendar, or — on a page with no calendar — in its
+ * owning note's.
+ *
+ * @param {string} [calendar] - The page's calendar, a canonical Address.
+ * @returns {string} The column's expression.
+ */
+const whenColumn = (calendar) => (calendar ? `e.whenIn[${literal(calendar)}]` : "e.whenText");
+
 /** The order every view sorts its rows in: by date, undated last. */
 const BY_DATE = "ORDER BY e.whenSort NULLS LAST, e.address";
 
@@ -65,8 +76,9 @@ const BY_DATE = "ORDER BY e.whenSort NULLS LAST, e.address";
  *
  * @type {ReadonlyArray<Readonly<{slug: string, heading: string,
  *   applies: (record: object) => boolean,
- *   query: (self: string[], shape: CorpusShape) => {fence: string, own?: string}|null,
- *   owners?: (db: object, selves: string[][], shape: CorpusShape) => Promise<Set<string>>}>>}
+ *   query: (self: string[], shape: CorpusShape, columns?: {felt?: boolean, calendar?: string}) => {fence: string, own?: string}|null,
+ *   owners?: (db: object, selves: string[][], shape: CorpusShape) => Promise<Set<string>>,
+ *   felt?: (db: object, selves: string[][], shape: CorpusShape) => Promise<Set<string>>}>>}
  */
 export const EVENT_VIEWS = Object.freeze([
     Object.freeze({
@@ -75,6 +87,7 @@ export const EVENT_VIEWS = Object.freeze([
         applies: (record) => record.type === "place",
         query: chronologyQuery,
         owners: chronologyOwners,
+        felt: chronologyFeltOwners,
     }),
     Object.freeze({
         slug: "events",
@@ -85,14 +98,14 @@ export const EVENT_VIEWS = Object.freeze([
             (record.type === "lore" && record.subType === "culture"),
         owners: (db, selves, shape) =>
             namedOwners(db, selves, "SELECT unnest(who).ref AS ref FROM events", shape.who),
-        query: (self, shape) => {
+        query: (self, shape, columns = {}) => {
             if (!shape.who) return null;
             const named = `list_filter(e.who, w -> w.ref IN (${literals(self)}))`;
             return {
                 fence: [
                     "SELECT e.note AS _ref,",
+                    `       ${whenColumn(columns.calendar)} AS "When",`,
                     '       e.summary AS "What happened",',
-                    '       e."when" AS "When",',
                     `       array_to_string(list_transform(${named}, w -> w.role), ', ') AS "Role"`,
                     "FROM events e",
                     `WHERE len(${named}) > 0`,
@@ -115,13 +128,13 @@ export const EVENT_VIEWS = Object.freeze([
                 'SELECT account."by" AS ref FROM (SELECT unnest(accounts) AS account FROM events)',
                 shape.accounts,
             ),
-        query: (self, shape) => {
+        query: (self, shape, columns = {}) => {
             if (!shape.accounts) return null;
             return {
                 fence: [
                     "SELECT e.note AS _ref,",
+                    `       ${whenColumn(columns.calendar)} AS "When",`,
                     '       e.summary AS "Event",',
-                    '       e."when" AS "When",',
                     '       e.account.says AS "What they say",',
                     '       e.account.agrees AS "Agrees"',
                     "FROM (SELECT *, unnest(accounts) AS account FROM events) e",
@@ -143,7 +156,7 @@ export const EVENT_VIEWS = Object.freeze([
                     "FROM (SELECT unnest(follows) AS edge FROM events)",
                 shape.follows,
             ),
-        query: (self, shape) => {
+        query: (self, shape, columns = {}) => {
             if (!shape.follows) return null;
             const edges =
                 `list_filter(e.follows, f -> split_part(f.event, '#', 1) ` +
@@ -151,8 +164,8 @@ export const EVENT_VIEWS = Object.freeze([
             return {
                 fence: [
                     "SELECT e.note AS _ref,",
+                    `       ${whenColumn(columns.calendar)} AS "When",`,
                     '       e.summary AS "What followed",',
-                    '       e."when" AS "When",',
                     `       array_to_string(list_transform(${edges}, f -> f.how), ', ') AS "How"`,
                     "FROM events e",
                     `WHERE len(${edges}) > 0`,
@@ -237,6 +250,36 @@ function chronologyOwnRows(shape) {
  * @returns {Promise<Set<string>>} The roots with at least one own row.
  */
 async function chronologyOwners(db, selves, shape) {
+    return chronologyRoots(db, selves, shape, chronologyOwnRows(shape));
+}
+
+/**
+ * Which places have a row felt there, asked of every place in one query. A
+ * chronology prints its `Felt here` column only for these.
+ *
+ * @param {object} db - From {@link module:engine/sql-tables.openNotesDatabase}.
+ * @param {string[][]} selves - Each place's Address, in each form.
+ * @param {CorpusShape} shape - What the corpus states.
+ * @returns {Promise<Set<string>>} The roots with at least one felt row.
+ */
+async function chronologyFeltOwners(db, selves, shape) {
+    if (!shape.reach) return new Set();
+    return chronologyRoots(db, selves, shape, [
+        `len(list_filter(${chronologyFelt()}, r -> coalesce(r.how, '') <> '')) > 0`,
+    ]);
+}
+
+/**
+ * The roots among `selves` for which an event satisfies one of `conditions`,
+ * over the places at or below each root.
+ *
+ * @param {object} db - From {@link module:engine/sql-tables.openNotesDatabase}.
+ * @param {string[][]} selves - Each place's Address, in each form.
+ * @param {CorpusShape} shape - What the corpus states.
+ * @param {string[]} conditions - Alternatives over `e` and `here.places`.
+ * @returns {Promise<Set<string>>} The roots with at least one such event.
+ */
+async function chronologyRoots(db, selves, shape, conditions) {
     const values = [...new Set(selves.map((self) => self[0]))]
         .map((root) => `(${literal(root)})`)
         .join(", ");
@@ -258,7 +301,7 @@ async function chronologyOwners(db, selves, shape) {
             "here AS (SELECT root, list(place) AS places FROM below GROUP BY root)",
             "SELECT DISTINCT here.root AS root",
             "FROM events e, here",
-            `WHERE ${chronologyOwnRows(shape).join(" OR ")}`,
+            `WHERE ${conditions.join(" OR ")}`,
         ].join("\n"),
     );
     return new Set(rows.map((row) => String(row.root)));
@@ -275,10 +318,13 @@ async function chronologyOwners(db, selves, shape) {
  *
  * @param {string[]} self - The place's Address, in each form.
  * @param {CorpusShape} shape - What the corpus states.
+ * @param {{felt?: boolean, calendar?: string}} [columns] - `felt: false` when
+ *   no row of this place is felt there, which leaves the `Felt here` column
+ *   out; `calendar`, the page's calendar, which the `When` column prints in.
  * @returns {{fence: string, own: string}|null} The query, and the one that
  *   counts the place's own rows.
  */
-function chronologyQuery(self, shape) {
+function chronologyQuery(self, shape, columns = {}) {
     if (!shape.locus && !shape.reach) return null;
     const below =
         shape.parents ?
@@ -298,11 +344,13 @@ function chronologyQuery(self, shape) {
         ...below,
         "here AS (SELECT list(place) AS places FROM below)",
         "SELECT e.note AS _ref,",
-        '       e.summary AS "What happened",',
-        '       e."when" AS "When",',
-        shape.reach ?
-            `       array_to_string(list_transform(${felt}, r -> r.how), '; ') AS "Felt here"`
-        :   '       NULL AS "Felt here"',
+        `       ${whenColumn(columns.calendar)} AS "When",`,
+        shape.reach && columns.felt !== false ?
+            '       e.summary AS "What happened",'
+        :   '       e.summary AS "What happened"',
+        ...(shape.reach && columns.felt !== false ?
+            [`       array_to_string(list_transform(${felt}, r -> r.how), '; ') AS "Felt here"`]
+        :   []),
         "FROM events e, here",
     ];
     const context = shape.depth ? ["e.depth = 'world'"] : [];
@@ -394,6 +442,7 @@ export async function eventViewSections(db, records, fileOf, only) {
     // A view that can say which notes have rows in one query is asked once, over
     // every note it will be given, and the per-note count is skipped.
     const owned = new Map();
+    const felt = new Map();
     for (const view of EVENT_VIEWS) {
         if (!view.owners) continue;
         const selves = [];
@@ -404,7 +453,10 @@ export async function eventViewSections(db, records, fileOf, only) {
             const self = selfForms(record);
             if (view.query(self, shape)) selves.push(self);
         }
-        if (selves.length) owned.set(view.slug, await view.owners(db, selves, shape));
+        if (selves.length) {
+            owned.set(view.slug, await view.owners(db, selves, shape));
+            if (view.felt) felt.set(view.slug, await view.felt(db, selves, shape));
+        }
     }
     for (const record of all) {
         if (!record?.address || record.documents || !record.shortcode) continue;
@@ -413,7 +465,12 @@ export async function eventViewSections(db, records, fileOf, only) {
         const sections = new Map();
         for (const view of EVENT_VIEWS) {
             if (!view.applies(record) || authoredSection(record, view.slug)) continue;
-            const query = view.query(self, shape);
+            const query = view.query(self, shape, {
+                ...(felt.has(view.slug) ? { felt: felt.get(view.slug).has(self[0]) } : {}),
+                ...(calendarAddress(record.resolvedCalendar) ?
+                    { calendar: calendarAddress(record.resolvedCalendar) }
+                :   {}),
+            });
             if (!query) continue;
             const has =
                 owned.has(view.slug) ?

package/engine/frontmatter-lint.mjs

@@ -1285,6 +1285,17 @@ export function lintNote(
                     });
                 }
             }
+            if (
+                Object.hasOwn(name, "sort") &&
+                (typeof name.sort !== "string" || !name.sort.trim())
+            ) {
+                findings.push({
+                    file: note.file,
+                    ...nameAt(["sort"]),
+                    severity: "error",
+                    message: "`name.sort` must be a nonempty string",
+                });
+            }
             for (const key of CHARACTER_NAME_KEYS) {
                 if (!Object.hasOwn(name, key) || !allowed.has(key)) continue;
                 if (typeof name[key] === "string" && name[key].trim()) continue;

package/engine/generated-sections.mjs

@@ -41,6 +41,13 @@
  * @module
  */
 
+/**
+ * The anchor of the Chronology section, which the book sets across the page.
+ *
+ * @type {string}
+ */
+export const CHRONOLOGY_SLUG = "chronology";
+
 /**
  * Every generated section, in the order it follows the author's text: where a
  * place sits and who governs it, then what happened, then what was written
@@ -53,7 +60,7 @@ export const GENERATED_SECTIONS = Object.freeze(
         { slug: "within", heading: "Within" },
         { slug: "governedby", heading: "Governed by" },
         { slug: "governedplaces", heading: "Governed places" },
-        { slug: "chronology", heading: "Chronology" },
+        { slug: CHRONOLOGY_SLUG, heading: "Chronology" },
         { slug: "events", heading: "Events" },
         { slug: "accounts", heading: "Accounts" },
         { slug: "followed", heading: "What followed" },