@heroiclands/package-build 23.12.4 → 23.12.5

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @heroiclands/package-build
 
+## 23.12.5
+
+### Patch Changes
+
+In PDF books, the page number and section name at the foot of each page are set at the size of the body text.
+
+In PDF books, list items sit apart from one another and carry a bullet large enough to see at book size.
+
+In PDF books, a reference to another book that already sits in brackets joins them, reading (The Crossing, Thal. p524) rather than nesting a second pair.
+
+Chronology sections, and the other event sections, list each event's date first, written in the setting's calendar. A chronology shows its Felt here column only when some event is felt in the place, and prints across the full page in PDF books. A captioned table can ask to span the page in a PDF book with `.full-width`. A wide table floats to where it fits, and the text runs on past its heading rather than leaving an empty page.
+
+In PDF books, a profile box too long for the rest of a page continues on the next one between its rows, instead of running off the page over the footer.
+
+A note's name may give a `sort` form, the way an index would write it: `sort: Black Flame, The` for _The Black Flame_, or `sort: Hilvan, Doran`. It files the note in the book index, page lists and other name-ordered lists, and it is the note's entry text in the book index; every other list still shows the full name. Authored `sql` fences can order by the new `nameSort` column of `entries`, which is the `sort` form or, without one, the full name.
+
+Profile figures read as numbers do: 12,500 under a million, and 11 million or 1.2 million above it, on the website, in Foundry and in PDF books.
+
 ## 23.12.4
 
 ### Patch Changes

package/docs/api.md

@@ -384,6 +384,7 @@ The declared infobox: what a note's summary panel holds, decided once and render
 | `assertInfoboxSet`        | `assertInfoboxSet(boxes, fm, options)` | `readonly object[]`, throws | refusing a page that carries anything but the boxes its type maps to                   |
 | `buildInfoboxes`          | `buildInfoboxes(fm, options)`          | `object[]`                  | building every box a note carries, against a given set of maps and declarations        |
 | `defineInfobox`           | `defineInfobox(declaration)`           | `object`                    | declaring one system's half of the infobox                                             |
+| `formatQuantity`          | `formatQuantity(value)`                | `string`                    | writing a number as a profile shows it: `12,500` under a million, `11 million` above   |
 | `hasRenderableValue`      | `hasRenderableValue(kind, value)`      | `boolean`                   | deciding whether a built value is worth a row                                          |
 | `hasValue`                | `hasValue(value)`                      | `boolean`                   | deciding whether an authored value is worth a row                                      |
 | `humanizeFieldName`       | `humanizeFieldName(name)`              | `string`                    | turning a declared key into the label a reader sees                                    |

package/docs/authoring/frontmatter.md

@@ -21,7 +21,7 @@ data: {}
 ---
 ```
 
-`name` is a map with a required, nonempty `full` display name. Every note may also use `aliases` for an ordered list of other names. The note infobox lists aliases directly beneath the full name. For a `being` with `subType: character`, `given` and `clan` are optional name components. The first alias of a character or NPC is its nickname. Omit optional keys when they do not apply; `given`, `clan`, and alias entries must be nonempty strings when present. No other keys are accepted under `name`.
+`name` is a map with a required, nonempty `full` display name. Every note may also use `aliases` for an ordered list of other names, and `sort` for the form the name takes in an index, such as `Black Flame, The` or `Hilvan, Doran`. The note infobox lists aliases directly beneath the full name. `sort` files the note wherever notes are ordered by name — the book index, page lists, generated lists of related notes, and the `nameSort` column of the `entries` relation — and is the note's entry text in the book index. Every other list still displays the `full` name. A note with no `sort` files and indexes by its `full` name. For `name: {full: The Black Flame, sort: "Black Flame, The"}`, the book index prints _Black Flame, The_ under **B**, and a page list prints _The Black Flame_ at the same place.
 
 `description` is the short page summary. `tags` hold draft state and descriptive labels. The note type's classification belongs in `subType` where it is declared. `data` holds facts about the subject shared by systems. A YAML comment is the place for an author-only note: commented values remain valid YAML but do not enter the content index or generated documents.
 

package/docs/authoring/links-and-markup.md

@@ -197,7 +197,7 @@ The caption attaches to exactly the next supported block:
 
 The optional `type` attribute overrides inference and accepts `figure`, `table`, `poetry`, `code`, `prose`, and `example`. `type=example` uses **Example 1**, **Example 2**, and so on. It does not allow an unsupported target. A heading, list, thematic break, another caption or end of document after a caption is an error. Caption markers without separating spaces or caption text are errors too.
 
-Identifiers are optional and must be unique within the note. Classes are unrestricted; `.border` uses the shared border style, while other classes can be styled by the medium. Named attributes use `key=value`, with quoted values for text containing spaces. Use `#id` and `.class` rather than `id=` and `class=`; event-handler attributes are refused.
+Identifiers are optional and must be unique within the note. Classes are unrestricted; `.border` uses the shared border style, while other classes can be styled by the medium. On a captioned table or SQL fence, `.full-width` sets the table across the page in a PDF book instead of in one column (`: Regional trade routes {.full-width}`); the other surfaces ignore it. Named attributes use `key=value`, with quoted values for text containing spaces. Use `#id` and `.class` rather than `id=` and `class=`; event-handler attributes are refused.
 
 Each numbered type has its own counter. Websites and Foundry number within a note; books number across their reading order. Unnumbered captions neither display nor consume a number. A map image can retain its asset-derived **Map** classification when no type is specified.
 
@@ -543,7 +543,7 @@ A column's heading is its SQL alias, so `AS "Name"` is what a reader sees. A cel
 | `market`           | The market scale as three columns — `value`, `name`, `trade` — so a table can print `village` beside the number a note wrote.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `<package>.notes`  | The same relations — `notes`, `entries`, `events`, `names`, `words`, `affixes`, `fields`, `glossary`, `language_lineage`, `dictionary`, `terms`, `register`, `tongues`, `retired`, `scope`, `letters`, `edges`, `clusters`, `stress`, `finals`, `syllables`, `joining`, `joins`, `marks`, `skeleton`, `frames`, `read_past`, `mutations`, `cluster_groups`, `sound_changes`, `elements`, `roots`, `cognates`, `calling_names`, `older`, `negation`, `name_shapes`, `name_edges`, `name_draws`, `held_from` and `near_names` — for each package this one declares a dependency on, in a schema named for it. |
 
-Nested frontmatter is addressed exactly as a note writes it: `name.full`, `sohl.weight`, `data.born`. Every Address is a string — the full canonical Address, as in `list_contains(data.parents, 'thalorna-note-place-xerathia')` — whichever package published it. Every note carries a computed `state` column of `full`, `draft` or `stub`. Notes tagged `gm` are absent from the relations on public surfaces.
+Nested frontmatter is addressed exactly as a note writes it: `name.full`, `sohl.weight`, `data.born`. Every Address is a string — the full canonical Address, as in `list_contains(data.parents, 'thalorna-note-place-xerathia')` — whichever package published it. Every note carries a computed `state` column of `full`, `draft` or `stub`, and a `nameSort` column holding its `name.sort` or, without one, its `name.full`, to `ORDER BY`. Notes tagged `gm` are absent from the relations on public surfaces.
 
 ### Sections the build adds
 
@@ -567,7 +567,7 @@ The vale holds three villages, of which only [[place-ford|Ford]] is walled.
 
 ### Sections the build adds about events
 
-A note's events are listed for you on the notes they concern: a place gets a **Chronology** of what happened there and below it, with every `depth: world` event as context, a being, affiliation or people the **Events** it took part in, an affiliation, place or people the **Accounts** it gives, and a note holding events **What followed** them. Each is a section appended after everything you wrote, with a fixed anchor — `chronology`, `events`, `accounts`, `followed` — and it appears only where it has something to list.
+A note's events are listed for you on the notes they concern: a place gets a **Chronology** of what happened there and below it, with every `depth: world` event as context, a being, affiliation or people the **Events** it took part in, an affiliation, place or people the **Accounts** it gives, and a note holding events **What followed** them. Each is a section appended after everything you wrote, with a fixed anchor — `chronology`, `events`, `accounts`, `followed` — and it appears only where it has something to list. Each lists the date first, written in the setting's calendar, followed by what happened; a Chronology adds a **Felt here** column only where some event is felt in the place, and a PDF book prints it across the full page width.
 
 To replace one, write the section yourself with the same anchor. The build then adds nothing for it and leaves yours exactly as written:
 
@@ -577,7 +577,7 @@ To replace one, write the section yourself with the same anchor. The build then
 The fells keep no reckoning before the raising.
 
 ```sql
-SELECT summary AS "What happened", "when" AS "When"
+SELECT summary AS "What happened", whenText AS "When"
 FROM events
 WHERE list_contains("where".locus, 'thalorna-note-place-ironfells')
 ORDER BY whenSort

package/docs/configuration.md

@@ -1259,7 +1259,9 @@ Each entry of `pdf.books` is one PDF:
   abbreviation and the page, and the other book's index, when
   `pdf.indexSeeAlso` is on, lists the note as `Name: Aelw. p307`. A book
   with no abbreviation is named by its full title in italics, `Name (_Book
-title_, p. 307)`. Each abbreviation is used once, since a reader could not
+title_, p. 307)`. A link the text closes a bracket on takes the reference
+  inside that bracket after a comma, so `(see The Crossing)` prints
+  `(see The Crossing, Thal. p524)` rather than nesting brackets. Each abbreviation is used once, since a reader could not
   tell which book to open from one shared by two.
 - `contents` is the tree written inline — the same `sectionName` /
   `contents` / `filter` / `file` shape a tree file holds under its own

package/docs/guides/book.md

@@ -174,11 +174,11 @@ the Lyrebird Inn (The Tenebrae Volume, p. 214)
 
 Which form a wikilink takes depends on where its target is printed:
 
-| The target is                                                 | The link prints                                                                      |
-| ------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
-| An entry of the same book, including a note the book reprints | An internal destination                                                              |
-| An entry of another book, and not of this one                 | `Name (_Book title_, p. N)`, or `Name (Aelw. pN)` with an abbreviation, with no link |
-| A note in no book                                             | The web address of the note's page                                                   |
+| The target is                                                 | The link prints                                                                                                                            |
+| ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| An entry of the same book, including a note the book reprints | An internal destination                                                                                                                    |
+| An entry of another book, and not of this one                 | `Name (_Book title_, p. N)`, or `Name (Aelw. pN)` with an abbreviation, with no link; inside a bracket the text closes, `(Name, Aelw. pN)` |
+| A note in no book                                             | The web address of the note's page                                                                                                         |
 
 The page is the page the PDF itself numbers, which is the number printed in the
 footer and used by the contents and the index, so the printed `p. N` is the
@@ -406,12 +406,12 @@ A book that prints at least one note ends with an **Index** chapter, grouped
 under letter headings. Nothing configures it: the build derives it from the
 notes the book prints.
 
-| Term                     | Source                | Shown as                                                                           |
-| ------------------------ | --------------------- | ---------------------------------------------------------------------------------- |
-| A note's name            | `name.full`           | the page of the note's entry in **bold**, then the pages of every authored mention |
-| A name without its head  | `name.full`           | the same pages as the note's entry, filed as `Targud, Kingdom of`                  |
-| An alias                 | `name.aliases`        | _see_ the note's name                                                              |
-| An event's in-world name | `data.events[].names` | _see_ the name of the note that holds the event                                    |
+| Term                     | Source                        | Shown as                                                                           |
+| ------------------------ | ----------------------------- | ---------------------------------------------------------------------------------- |
+| A note's name            | `name.sort`, else `name.full` | the page of the note's entry in **bold**, then the pages of every authored mention |
+| A name without its head  | `name.full`                   | the same pages as the note's entry, filed as `Targud, Kingdom of`                  |
+| An alias                 | `name.aliases`                | _see_ the note's name                                                              |
+| An event's in-world name | `data.events[].names`         | _see_ the name of the note that holds the event                                    |
 
 A name that opens with a generic word a reader would not look under, such as
 `Kingdom of Targud` or `Ritual: Blessing`, is also filed under the rest of the
@@ -460,7 +460,7 @@ Two kinds of link add nothing:
 
 Terms sort on the ASCII fold the content index derives for names (`nameAscii`),
 ignoring case, so an accented name files under its base letter and the order
-matches the table of contents. A term that does not begin with a letter files
+matches the table of contents. A note's own entry reads as its `name.sort` when it declares one, in index form such as `Black Flame, The` or `Hilvan, Doran`, and as its `name.full` otherwise; it files, and takes its letter heading, from that form. A note that declares a `sort` is not also filed under `pdf.indexHeads`. A term that does not begin with a letter files
 first, under `#`. An alias or event name that folds to the same text as the
 note's own name is not listed again.
 

package/docs/reference/format-details.md

@@ -379,7 +379,13 @@ content, comment out its YAML lines with `#`. Comments remain valid YAML text
 and do not become data in the JSONL index, generated pages, or Foundry documents.
 
 `name` is a map with a required nonempty `full` string when present. It may
-also contain `aliases`, an ordered list of nonempty strings. A being with
+also contain `aliases`, an ordered list of nonempty strings, and `sort`, a nonempty
+string giving the form the name takes in an index, such as `Black Flame, The` or
+`Hilvan, Doran`. `sort` files the note wherever notes are ordered by name (page
+lists, generated lists of related notes, the book index, the `nameSort` column)
+and is the note's entry text in the book index; every other list still displays
+`full`. Without `sort`, the note files and indexes by `full`. Ordering compares
+the ASCII fold of the key (`Árdavon` files beside `Ardavon`). A being with
 `subType: character` may additionally contain nonempty `given` and `clan`
 strings. Other keys under `name` are errors. For a character or NPC, the first
 alias is its nickname. A being's homes belong in `data.homes`.
@@ -2916,7 +2922,9 @@ reads `NULL` rather than failing. `data.culture` is the one field that reads as
 a derived value: the note's own culture, or the one it inherits. See
 [Culture in the index](#culture-in-the-index).
 
-**`notes` leaves out stubs; `entries` does not.** Both carry a derived `state`
+**`notes` leaves out stubs; `entries` does not.** Both carry a derived `nameSort`
+column — the note's `name.sort` when it declares one, otherwise its `name.full`,
+unfolded — for `ORDER BY`, and a derived `state`
 column — `stub`, `draft` or `full` — and `notes` is exactly
 `SELECT * FROM entries WHERE state <> 'stub'`. So every table already written
 selects what it always selected, and gains `state` for free; a table that should
@@ -2957,20 +2965,21 @@ query rather than a list kept by hand:
 
 ````markdown
 ```sql
-SELECT note AS _ref, "when" AS "When", summary AS "What happened"
+SELECT note AS _ref, whenText AS "When", summary AS "What happened"
 FROM events
 WHERE kind IN ('war', 'siege', 'battle')
 ORDER BY whenSort
 ```
 ````
 
-| Column                   | What it holds                                                                                                                                                                                                               |
-| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `note`                   | The canonical Address of the note the event is written on.                                                                                                                                                                  |
-| `address`                | The event's own Address: `note#id` where the event has an `id`, the note's Address alone where it has none.                                                                                                                 |
-| `id`, `kind`, `depth`, … | Every key of an event, each its own column under its own name — `id`, `kind`, `depth`, `when`, `until`, `recurs`, `summary`, `standing`, `names`, `where`, `who`, `follows`, `accounts`, `unresolved`, `sources`, `stated`. |
-| `whenSort`, `untilSort`  | The date's position on the canonical axis: the canonical year, with a day as its fraction of the year where the calendar states the year's length. `ORDER BY whenSort` is date order.                                       |
-| `whenYear`, `untilYear`  | The canonical year alone, for a filter such as `whenYear BETWEEN 200 AND 299`.                                                                                                                                              |
+| Column                   | What it holds                                                                                                                                                                                                                                                                                  |
+| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `note`                   | The canonical Address of the note the event is written on.                                                                                                                                                                                                                                     |
+| `address`                | The event's own Address: `note#id` where the event has an `id`, the note's Address alone where it has none.                                                                                                                                                                                    |
+| `id`, `kind`, `depth`, … | Every key of an event, each its own column under its own name — `id`, `kind`, `depth`, `when`, `until`, `recurs`, `summary`, `standing`, `names`, `where`, `who`, `follows`, `accounts`, `unresolved`, `sources`, `stated`.                                                                    |
+| `whenSort`, `untilSort`  | The date's position on the canonical axis: the canonical year, with a day as its fraction of the year where the calendar states the year's length. `ORDER BY whenSort` is date order.                                                                                                          |
+| `whenText`, `untilText`  | The date as a reader sees it, printed as `dateformat` prints it in the calendar the owning note names in `data.calendar`, else the one the world note names, else in the era the date itself names; `~` marks an approximate date. A date that does not resolve keeps the text its note wrote. |
+| `whenYear`, `untilYear`  | The canonical year alone, for a filter such as `whenYear BETWEEN 200 AND 299`.                                                                                                                                                                                                                 |
 
 `when` and `until` read as the text the note wrote, `~` included. The sort
 keys and years are positions on the canonical axis, which counts a year `0`
@@ -3498,7 +3507,7 @@ The caption attaches to exactly the next supported block:
 
 The optional `type` attribute overrides inference and accepts `figure`, `table`, `poetry`, `code`, `prose`, and `example`. `type=example` uses **Example 1**, **Example 2**, and so on. It does not allow an unsupported target. A heading, list, thematic break, another caption or end of document after a caption is an error. Caption markers without separating spaces or caption text are errors too.
 
-Identifiers are optional and must be unique within the note. Classes are unrestricted; `.border` uses the shared border style, while other classes can be styled by the medium. Named attributes use `key=value`, with quoted values for text containing spaces. Use `#id` and `.class` rather than `id=` and `class=`; event-handler attributes are refused.
+Identifiers are optional and must be unique within the note. Classes are unrestricted; `.border` uses the shared border style, while other classes can be styled by the medium. On a captioned table or SQL fence, `.full-width` sets the table across the page in a PDF book instead of in one column (`: Regional trade routes {.full-width}`); the other surfaces ignore it. Named attributes use `key=value`, with quoted values for text containing spaces. Use `#id` and `.class` rather than `id=` and `class=`; event-handler attributes are refused.
 
 Each numbered type has its own counter. Websites and Foundry number within a note; books number across their reading order. Unnumbered captions neither display nor consume a number. A map image can retain its asset-derived **Map** classification when no type is specified.
 
@@ -3763,11 +3772,14 @@ The build appends sections to the end of a note's body that list the events conc
 
 | View          | Anchor       | On                                                               | Rows                                                                                                                                                                              | Columns                            |
 | ------------- | ------------ | ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
-| Chronology    | `chronology` | a `place`                                                        | events whose `where.locus` names the place or a place below it in `parents`; events whose `where.reach` names one, with that entry's `how`; every `depth: world` event as context | What happened, When, Felt here     |
-| Events        | `events`     | a `being`, an `affiliation`, a `lore` note of `subType: culture` | events whose `who[].ref` names the note, with the role it played                                                                                                                  | What happened, When, Role          |
-| Accounts      | `accounts`   | an `affiliation`, a `place`, a `lore` note of `subType: culture` | each `accounts[]` entry the note gives, with the event it concerns                                                                                                                | Event, When, What they say, Agrees |
-| What followed | `followed`   | a note holding events                                            | events whose `follows[].event` names one of this note's events, with how                                                                                                          | What followed, When, How           |
-
+| Chronology    | `chronology` | a `place`                                                        | events whose `where.locus` names the place or a place below it in `parents`; events whose `where.reach` names one, with that entry's `how`; every `depth: world` event as context | When, What happened, Felt here     |
+| Events        | `events`     | a `being`, an `affiliation`, a `lore` note of `subType: culture` | events whose `who[].ref` names the note, with the role it played                                                                                                                  | When, What happened, Role          |
+| Accounts      | `accounts`   | an `affiliation`, a `place`, a `lore` note of `subType: culture` | each `accounts[]` entry the note gives, with the event it concerns                                                                                                                | When, Event, What they say, Agrees |
+| What followed | `followed`   | a note holding events                                            | events whose `follows[].event` names one of this note's events, with how                                                                                                          | When, What followed, How           |
+
+- **Every view's first column is When**, the event's date written in the setting's calendar — the `events` relation's `whenText` column. An event whose date does not resolve shows the text its note wrote.
+- **A chronology's Felt here column appears only where some row is felt in the place.** A place whose rows are all events that happened there, or world events, has the When and What happened columns alone.
+- **A chronology is always set across the full page width in a PDF book**, whatever its columns.
 - **The views follow everything the author wrote**, in the order of the [generated sections](#generated-sections).
 - **A view with no rows is not generated.** A chronology is generated only where the place has rows of its own; the world events beside them are context and make no chronology by themselves.
 - **An author's own section replaces a view.** A note whose body declares a prose anchor with the view's slug — `# Chronology {#chronology}`, or a block or span with that `id` — gets no generated section for it, and its own section is left exactly as written. This is the one way to turn a view off, and the way to choose a different table: write the section and its own `sql` fence.

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.                                                                   |

package/engine/content-index.mjs

@@ -108,8 +108,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";
@@ -245,44 +246,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.
  *

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,10 +25,16 @@
  * `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 sees them**: printed
+ * as the `dateformat` helper prints a date, in the calendar the owning note
+ * names in `data.calendar`, else the one the world note names, else in the era
+ * the date itself names. A date that does not resolve keeps its authored text.
+ *
  * @module
  */
 
 import { ownDocumentSystem, renderAddress } from "./address.mjs";
+import { printEventDateIn } from "./event-fields.mjs";
 import { EVENT_ENTRY_KEYS } from "./note-event-terms.mjs";
 
 /** The columns a row carries besides the event's own keys, before them. */
@@ -37,11 +43,15 @@ 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"]);
+
 /** 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,
 ]);
 
 /** The keys whose authored value is a date, printed as the text it was written as. */
@@ -84,22 +94,41 @@ function axisKeys(date) {
     };
 }
 
+/**
+ * The calendar the world note names, which displays every date whose own note
+ * names none.
+ *
+ * @param {Record<string, any>[]} records - Index records.
+ * @returns {string|undefined} The calendar's Address or shortcode.
+ */
+function worldCalendar(records) {
+    for (const record of records) {
+        if (record?.type === "place" && record.data?.year?.days && record.data.calendar)
+            return String(record.data.calendar);
+    }
+    return undefined;
+}
+
 /**
  * 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.
  * @returns {object[]} One row per event entry, in record then entry order.
  */
-export function eventRows(records) {
+export function eventRows(records, dates) {
     const rows = [];
-    for (const record of records) {
+    const all = [...records];
+    const world = worldCalendar(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 = record.data?.calendar ? String(record.data.calendar) : world;
         events.forEach((entry, position) => {
             if (!entry || typeof entry !== "object" || Array.isArray(entry)) return;
             const row = {
@@ -119,6 +148,12 @@ export function eventRows(records) {
             row.whenYear = when.year;
             row.untilSort = until.sort;
             row.untilYear = until.year;
+            for (const key of DATE_KEYS) {
+                row[`${key}Text`] =
+                    row[key] === null ?
+                        null
+                    :   printEventDateIn(row[key], resolved[position]?.[key], dates, calendar);
+            }
             rows.push(row);
         });
     }

package/engine/event-views.mjs

@@ -65,8 +65,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}) => {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 +76,7 @@ export const EVENT_VIEWS = Object.freeze([
         applies: (record) => record.type === "place",
         query: chronologyQuery,
         owners: chronologyOwners,
+        felt: chronologyFeltOwners,
     }),
     Object.freeze({
         slug: "events",
@@ -91,8 +93,8 @@ export const EVENT_VIEWS = Object.freeze([
             return {
                 fence: [
                     "SELECT e.note AS _ref,",
+                    '       e.whenText 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`,
@@ -120,8 +122,8 @@ export const EVENT_VIEWS = Object.freeze([
             return {
                 fence: [
                     "SELECT e.note AS _ref,",
+                    '       e.whenText 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",
@@ -151,8 +153,8 @@ export const EVENT_VIEWS = Object.freeze([
             return {
                 fence: [
                     "SELECT e.note AS _ref,",
+                    '       e.whenText 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 +239,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 +290,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 +307,12 @@ 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}} [columns] - `felt: false` when no row of this
+ *   place is felt there, which leaves the `Felt here` column out.
  * @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 +332,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"',
+        '       e.whenText 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 +430,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 +441,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 +453,11 @@ 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]) } : undefined,
+            );
             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;