@heroiclands/package-build 23.12.3 → 23.12.5

package/engine/pdf-build.mjs

@@ -780,6 +780,7 @@ export async function buildPdf({
             books: buildable.map((b) => ({
                 id: b.entry.id,
                 title: b.entry.title,
+                abbreviation: b.entry.abbreviation,
                 plan: b.selection.plan,
             })),
             homes,

package/engine/pdf-index.mjs

@@ -33,12 +33,15 @@
  *
  * Terms sort on the ASCII fold the content index derives for names
  * ({@link module:engine/content-index.asciiName}), ignoring case, so an
- * accented name files under its base letter.
+ * accented name files under its base letter. A note's own entry is its
+ * `name.sort` when it declares one (`Black Flame, The`, `Hilvan, Doran`) and
+ * its `name.full` otherwise; it prints, files and takes its letter heading
+ * from that one form.
  *
  * @module
  */
 
-import { asciiName } from "./content-index.mjs";
+import { asciiName, nameSortOf } from "./name-sort.mjs";
 
 /**
  * The marker an entry heading or an authored mention carries.
@@ -102,11 +105,13 @@ function letterOf(key) {
  * @param {string[]} [opts.heads] - Leading words (`pdf.indexHeads`) matched
  *   literally against the start of a name; a name that opens with one is also
  *   listed as `<rest>, <head>`, the head without its trailing space or colon. None when absent.
- * @param {Array<{slug: string, name: string, title: string, page: string|number}>} [opts.foreign] -
+ * @param {Array<{slug: string, name: string, title: string, abbreviation?: string,
+ *   page: string|number}>} [opts.foreign] -
  *   Notes another book prints, listed as `Name: Book title, p. N` once this
- *   book mentions them.
+ *   book mentions them, or `Name: Aelw. p12` when the home book has an
+ *   abbreviation.
  * @returns {Array<{letter: string, name: string, slug: string, see?: string,
- *   foreign?: {title: string, page: string}}>} Terms with `see` set for a
+ *   foreign?: {title: string, abbreviation?: string, page: string}}>} Terms with `see` set for a
  *   cross-reference to the main name it points at.
  */
 export function indexTerms(entries, { owns = () => true, foreign = [], heads = [] } = {}) {
@@ -123,8 +128,9 @@ export function indexTerms(entries, { owns = () => true, foreign = [], heads = [
     for (const entry of entries ?? []) {
         if (entry?.kind !== "note" || !owns(entry)) continue;
         const slug = slugOf(entry.record);
-        const name = String(entry.record?.name?.full ?? "").trim();
+        const name = String(nameSortOf(entry.record) ?? "").trim();
         if (!slug || !name || info.has(slug)) continue;
+        const declared = Boolean(String(entry.record?.name?.sort ?? "").trim());
         const parents = Array.isArray(entry.record?.data?.parents) ? entry.record.data.parents : [];
         const parent = parents
             .map((one) =>
@@ -137,7 +143,10 @@ export function indexTerms(entries, { owns = () => true, foreign = [], heads = [
         });
         terms.push({ name, slug, main: true });
         const taken = new Set([sortKey(name)]);
-        const head = byLength.find((one) => name.startsWith(one) && name.slice(one.length).trim());
+        const head =
+            declared ? undefined : (
+                byLength.find((one) => name.startsWith(one) && name.slice(one.length).trim())
+            );
         if (head) {
             const inverted = `${name.slice(head.length).trim()}, ${head.replace(/[\s:]+$/, "")}`;
             taken.add(sortKey(inverted));
@@ -198,7 +207,11 @@ export function indexTerms(entries, { owns = () => true, foreign = [], heads = [
         keyed.push({
             name,
             slug: other.slug,
-            foreign: { title: String(other.title), page: String(other.page) },
+            foreign: {
+                title: String(other.title),
+                ...(other.abbreviation ? { abbreviation: String(other.abbreviation) } : {}),
+                page: String(other.page),
+            },
             key: sortKey(name),
         });
     }
@@ -234,7 +247,7 @@ export function indexTerms(entries, { owns = () => true, foreign = [], heads = [
 export function indexPreamble({ seeAlso = false } = {}) {
     return [
         // Zero-size and invisible; the label is what the chapter queries.
-        "#let book-ix(key, main: false) = [#metadata((key: key, main: main)) <book-index>]",
+        "#let book-ix(key, main: false) = [#metadata((key: key, main: main))<book-index>]",
         "#let book-index(terms) = context {",
         "  set par(justify: false, first-line-indent: 0em, hanging-indent: 1em, spacing: 0.45em)",
         "  set text(size: 8.8pt)",
@@ -271,7 +284,12 @@ export function indexPreamble({ seeAlso = false } = {}) {
         ...(seeAlso ?
             [
                 "    if away != none {",
-                "      par[#term.name: #emph[#away.title], p. #away.page]",
+                '      let short = away.at("abbreviation", default: none)',
+                "      if short != none {",
+                "        par[#term.name: #short~p#away.page]",
+                "      } else {",
+                "        par[#term.name: #emph[#away.title], p. #away.page]",
+                "      }",
                 "      continue",
                 "    }",
             ]
@@ -309,8 +327,11 @@ export function indexChapter(entries, title, opts = {}) {
             }${
                 term.foreign === undefined ?
                     ""
-                :   `, foreign: (title: "${escapeString(term.foreign.title)}", ` +
-                    `page: "${escapeString(term.foreign.page)}")`
+                :   `, foreign: (title: "${escapeString(term.foreign.title)}", ${
+                        term.foreign.abbreviation === undefined ?
+                            ""
+                        :   `abbreviation: "${escapeString(term.foreign.abbreviation)}", `
+                    }` + `page: "${escapeString(term.foreign.page)}")`
             })`,
     );
     return [

package/engine/pdf-pages.mjs

@@ -39,6 +39,7 @@ import { spawnSync } from "node:child_process";
 import { encodeAddresses } from "./address-values.mjs";
 import { recordKey } from "./pdf-coverage.mjs";
 import { labelFor } from "./pdf-render.mjs";
+import { nameSortOf } from "./name-sort.mjs";
 
 /** What a reference prints for a page that has not been measured. */
 export const UNMEASURED_PAGE = "?";
@@ -142,7 +143,7 @@ export function readEntryPages(typPath, fontArgs, binary = "typst") {
  *   The books that render, in configuration order.
  * @param {Map<string, string>} input.homes - Each note's key → its home book's
  *   id, from {@link module:engine/pdf-coverage.coverage}.
- * @returns {Array<{key: string, book: string, title: string, anchor: string,
+ * @returns {Array<{key: string, book: string, title: string, abbreviation?: string, anchor: string,
  *   record: object, slug: string, aliases: string[]}>} One per homed note, in book order and
  *   then entry order.
  */
@@ -160,6 +161,7 @@ export function homeEntries({ books, homes }) {
                 key,
                 book: book.id,
                 title: book.title,
+                abbreviation: book.abbreviation,
                 anchor: entry.anchor,
                 record,
                 slug: String(record?.address?.slug ?? record?.shortcode ?? ""),
@@ -246,13 +248,21 @@ export function elsewhereFor({ entries, book, printed, table, seeAlso = false })
         const keys = [entry.slug, ...entry.aliases].filter((key) => key && !printed.has(key));
         const page = table?.[entry.key]?.page ?? UNMEASURED_PAGE;
         for (const key of keys) {
-            if (!map.has(key)) map.set(key, { slug: entry.slug, title: entry.title, page });
+            if (!map.has(key)) {
+                map.set(key, {
+                    slug: entry.slug,
+                    title: entry.title,
+                    abbreviation: entry.abbreviation,
+                    page,
+                });
+            }
         }
         if (seeAlso && entry.slug && !printed.has(entry.slug)) {
             listed.push({
                 slug: entry.slug,
-                name: String(entry.record?.name?.full ?? "").trim(),
+                name: String(nameSortOf(entry.record) ?? "").trim(),
                 title: entry.title,
+                abbreviation: entry.abbreviation,
                 page,
             });
         }

package/engine/pdf-render.mjs

@@ -75,6 +75,7 @@ import {
     imagePlugin,
 } from "./content-images.mjs";
 import { bookImageWidthIn } from "./pdf-images.mjs";
+import { CHRONOLOGY_SLUG } from "./generated-sections.mjs";
 
 /** Requested print width for every named image size. */
 export const BOOK_IMAGE_WIDTHS = Object.freeze({
@@ -738,6 +739,8 @@ function renderBlock(tokens, i, out, ctx) {
             // the same words later in the same entry.
             const base = anchor || slugify(plainHeadingText(inline)) || "heading";
             const unique = anchorFor(base, ctx.seen);
+            // The section a table falls in decides whether it spans the page.
+            ctx.section = base;
             const label = ` <${sectionLabel(ctx.anchorPrefix, unique)}>`;
             // A body heading is never printed and never bookmarked — it is
             // structure a reader reaches only by following a link, not a
@@ -841,12 +844,10 @@ function renderBlock(tokens, i, out, ctx) {
 }
 
 /**
- * Self-contained dictionary rows with the website's 150 CSS-pixel hanging indent.
- *
- * Each row remains a breakable block; only the bold term is an inline box. The
- * negative first-line space lets its label start at the original margin while
- * subsequent paragraphs, lists and blocks retain the definition's inset. A long
- * term enlarges its slot without changing the continuation margin.
+ * Definition rows set as a book sets them: the term in bold, run in at the
+ * margin, and the definition following on the same line, with its continuation
+ * lines and any further paragraphs, lists and blocks indented 1em. A long term
+ * takes no more room than a short one. Rows are spaced as paragraphs are.
  *
  * Scope the helper to this list so exported Markdown fragments also work without
  * a book preamble, including nested definition lists.
@@ -854,18 +855,12 @@ function renderBlock(tokens, i, out, ctx) {
  * @returns {string} Typst markup.
  */
 function renderDefinitionList(entries) {
-    return `#context {
-  let book-definition(term, body) = {
-    let indent = 112.5pt
-    let gap = (0.75em).to-absolute()
-    let label = text(weight: "bold", term)
-    let slot = calc.max(indent - gap, measure(label).width)
-    block(width: 100%, breakable: true, inset: (left: indent), above: 0pt, below: 0.5em)[
-      #set par(first-line-indent: 0pt, hanging-indent: 0pt)
-      #set text(weight: "regular")
-      #h(-indent)#box(width: slot, label)#h(gap)#body
-    ]
-  }
+    return `#{
+  let book-definition(term, body) = block(width: 100%, breakable: true, inset: (left: 1em))[
+    #set par(first-line-indent: 0pt, hanging-indent: 0pt)
+    #set text(weight: "regular")
+    #h(-1em)#text(weight: "bold", term)#h(0.5em)#body
+  ]
   ${entries.join("\n  ")}
 }`;
 }
@@ -1174,8 +1169,14 @@ function renderTable(tokens, ctx) {
     // Wide content is given an explicit span rather than left to overflow the
     // measure: past three columns a table is set across the page, and
     // `book-wide` decides between a float and pages of its own by measuring it.
-    if (columns > WIDE_TABLE_COLUMNS)
-        return `${caption ? "" : "\n#pagebreak(weak: true)\n"}\n#book-wide[\n${labelled}\n]\n\n`;
+    // A table can ask for the span, whatever its columns: its caption takes
+    // `.full-width`, and a Chronology section is always set that way. A wide
+    // table floats to where it fits and the text runs on past it, so a heading
+    // is never left alone above an empty page; its heading, caption and any
+    // reference to it are what lead a reader there.
+    const asked =
+        Boolean(caption?.classes?.includes("full-width")) || ctx.section === CHRONOLOGY_SLUG;
+    if (asked || columns > WIDE_TABLE_COLUMNS) return `\n#book-wide[\n${labelled}\n]\n\n`;
     return `\n${labelled}\n\n`;
 }
 
@@ -1303,7 +1304,11 @@ function renderInline(token, ctx) {
             case "link_open": {
                 const close = childMatching(children, i, "link_open", "link_close");
                 const inner = renderInline({ children: children.slice(i + 1, close) }, ctx);
-                out.push(renderLink(child.attrGet?.("href") ?? "", inner, ctx));
+                // A link the text closes a bracket on takes its reference
+                // inside that bracket.
+                const after = children[close + 1];
+                const bracketed = after?.type === "text" && after.content.startsWith(")");
+                out.push(renderLink(child.attrGet?.("href") ?? "", inner, ctx, { bracketed }));
                 i = close;
                 break;
             }
@@ -1419,9 +1424,11 @@ function pageOfLabel(label) {
  * @param {string} href - The resolved URL.
  * @param {string} inner - The already-rendered link text.
  * @param {object} ctx - Render context.
+ * @param {{bracketed?: boolean}} [opts] - `bracketed` when the text closes a
+ *   bracket right after the link; see {@link crossBookReference}.
  * @returns {string} Typst markup.
  */
-function renderLink(href, inner, ctx) {
+function renderLink(href, inner, ctx, { bracketed = false } = {}) {
     const url = String(href ?? "");
     const fragment = /#([^?]*)/.exec(url)?.[1] ?? "";
     if (url.startsWith("#") && fragment)
@@ -1449,7 +1456,7 @@ function renderLink(href, inner, ctx) {
         // A mention in authored prose is what lists the note, under
         // `pdf.indexSeeAlso`.
         const marker = ctx.indexMentions && ctx.elsewhere.seeAlso ? indexMarker(away.slug) : "";
-        return `${crossBookReference(inner, away)}${marker}`;
+        return `${crossBookReference(inner, away, { bracketed })}${marker}`;
     }
     if (!url || ctx.generated) return inner;
     return `#link("${escapeTypstString(absolutePageUrl(url, ctx.url))}")[${inner}]`;
@@ -1457,18 +1464,30 @@ function renderLink(href, inner, ctx) {
 
 /**
  * A reference to a note another book prints, as Typst: the words the link
- * carried, then the book and the page, `Name (_Book title_, p. 12)`.
+ * carried, then the book and the page. A book with an abbreviation reads
+ * `Name (Aelw. p12)`; one without reads `Name (_Book title_, p. 12)`.
+ *
+ * A link the text already closes a bracket on, as in `(see Name)`, takes the
+ * reference inside that bracket after a comma, `(see Name, Aelw. p12)`, so the
+ * brackets never nest.
  *
- * The space before the page number does not break, so a number never starts a
- * line of its own.
+ * The space before the page number, or between the abbreviation and the page,
+ * does not break, so a number never starts a line of its own.
  *
  * @param {string} inner - The already-rendered link text.
- * @param {{title: string, page: string|number}} away - The home book's title
- *   and the page the entry starts on.
+ * @param {{title: string, abbreviation?: string, page: string|number}} away -
+ *   The home book's title, its abbreviation when it declares one, and the page
+ *   the entry starts on.
+ * @param {{bracketed?: boolean}} [opts] - `bracketed` when the text closes a
+ *   bracket right after the link.
  * @returns {string} Typst markup.
  */
-export function crossBookReference(inner, away) {
-    return `${inner} (#emph[${escapeTypst(away.title)}], p.~${away.page})`;
+export function crossBookReference(inner, away, { bracketed = false } = {}) {
+    const where =
+        away.abbreviation ?
+            `${escapeTypst(away.abbreviation)}~p${away.page}`
+        :   `#emph[${escapeTypst(away.title)}], p.~${away.page}`;
+    return bracketed ? `${inner}, ${where}` : `${inner} (${where})`;
 }
 
 /**
@@ -1705,10 +1724,12 @@ export function bookTypstPreamble() {
             "    ]\n" +
             "  ])\n" +
             "]",
-        "#let book-ornament = box(baseline: 1pt, " +
-            "rotate(45deg, rect(width: 3pt, height: 3pt, fill: book-accent)))",
+        "#let book-ornament = box(baseline: 1.2pt, " +
+            "rotate(45deg, rect(width: 3.6pt, height: 3.6pt, fill: book-accent)))",
+        // The foot is set at the body's size, in the faint ink, so the page
+        // number and the section name read without being taken for text.
         "#let book-footer(name) = context {\n" +
-            "  set text(size: 8pt, fill: book-faint)\n" +
+            "  set text(fill: book-faint)\n" +
             "  grid(columns: (1fr, auto, 1fr), align(left)[#name], align(center)[#book-ornament],\n" +
             "    align(right)[#counter(page).display()])\n" +
             "}",
@@ -2033,6 +2054,12 @@ export function renderBook({
     // becomes wider than `1.`.
     out.push("#show list: set par(first-line-indent: 0em)");
     out.push("#show enum: set par(first-line-indent: 0em)");
+    // Items sit three-quarters of a line apart, so a list of several-line
+    // items reads as separate entries. The face's own bullet is small at book
+    // size, so it is enlarged and lifted to the middle of the first line; a
+    // nested level takes a dash.
+    out.push("#set list(spacing: 0.75em, marker: (text(size: 1.3em, baseline: -0.08em)[•], [–]))");
+    out.push("#set enum(spacing: 0.75em)");
     // The mono face is a separate claim from the book face: a fenced block is
     // the one place the corpus is allowed box-drawing characters, and the
     // serif that sets the prose is not the font that carries them.

package/engine/pdf-toc.mjs

@@ -49,6 +49,7 @@
  * @module
  */
 
+import { nameSortKey } from "./name-sort.mjs";
 import { encodeAddresses } from "./address-values.mjs";
 import { slugify } from "./content-slug.mjs";
 import { positionOfYamlPath } from "./diagnostics.mjs";
@@ -416,7 +417,7 @@ export async function runTreeFilters(nodes, db, { keep = () => true, text } = {}
  * without a renderer or a PDF. Only how the result *looks* needs eyes.
  *
  * **Notes are sorted, prose is not.** A section's entries come out in
- * `nameAscii` order — the ASCII fold `buildIndexRecord` already derives, so a
+ * name-sort order (`name.sort`, else `name.full`, folded to ASCII), so a
  * circumflex sorts with its letter instead of after `Z` as a raw codepoint
  * comparison would put it. Prose keeps the position it was written in, because
  * its place in the sequence is the author's statement.
@@ -566,8 +567,8 @@ function emitSection(node, nodes, ctx) {
  */
 function sortRecords(records) {
     return [...records].sort((a, b) => {
-        const an = a?.nameAscii ?? a?.name?.full ?? "";
-        const bn = b?.nameAscii ?? b?.name?.full ?? "";
+        const an = nameSortKey(a);
+        const bn = nameSortKey(b);
         if (an !== bn) return an < bn ? -1 : 1;
         const as = a?.address?.slug ?? "";
         const bs = b?.address?.slug ?? "";

package/engine/project-init.mjs

@@ -308,7 +308,7 @@ function projectText(answers) {
             "Labels are organization-level, defined in `HeroicLands/.github`.",
             "",
         ].join("\n"),
-        ".github/workflows/build.yml": [
+        ".gitea/workflows/build.yml": [
             "# SPDX-License-Identifier: GPL-3.0-or-later",
             "name: Build and Test",
             "on:",
@@ -424,7 +424,7 @@ export function checkProject(rootDir) {
         "LICENSE.md",
         ".changeset/config.json",
         ".github/ISSUE_REPORTING.md",
-        ".github/workflows/build.yml",
+        ".gitea/workflows/build.yml",
     ];
     for (const file of required) {
         if (!fs.existsSync(path.join(root, file))) add(file, "required project file is missing");

package/engine/related-pages.mjs

@@ -49,6 +49,8 @@ import { homepageAddresses } from "./homepage.mjs";
  *                          site-root-relative form the page states for itself.
  * @property {string} [gloss] Why the author recommends this page.
  * @property {string} type  The note's `type`, which the theme groups by.
+ * @property {string} [sort] The note's `name.sort`. It orders the list in place
+ *                          of `title` and is not published.
  */
 
 /**
@@ -73,7 +75,10 @@ import { homepageAddresses } from "./homepage.mjs";
  * @returns {number}
  */
 function byTypeThenTitle(a, b) {
-    return a.type.localeCompare(b.type, "en") || a.title.localeCompare(b.title, "en");
+    return (
+        a.type.localeCompare(b.type, "en") ||
+        (a.sort ?? a.title).localeCompare(b.sort ?? b.title, "en")
+    );
 }
 
 /**
@@ -118,7 +123,12 @@ export function relatedPages(edges, entries, deliberate = new Map()) {
     const list = (urls) =>
         [...urls]
             .map((url) => /** @type {RelatedEntry} */ (entries.get(url)))
-            .sort(byTypeThenTitle);
+            .sort(byTypeThenTitle)
+            .map((entry) => {
+                if (entry.sort === undefined) return entry;
+                const { sort, ...published } = entry;
+                return published;
+            });
 
     const out = new Map();
     for (const [url, { backlinks, mentions }] of graph) {

package/engine/site-build.mjs

@@ -1069,6 +1069,9 @@ export function renderPages(pages, options) {
             title: pageTitle(page),
             url: page.url,
             type: String(page.fm.type),
+            ...(typeof page.fm.name?.sort === "string" && page.fm.name.sort ?
+                { sort: page.fm.name.sort }
+            :   {}),
         });
     }
     for (const home of homepages) {

package/engine/sql-tables.mjs

@@ -32,6 +32,7 @@ import { expandContentTables } from "./content-tables.mjs";
 import { NOTE_VOCABULARY, isGmNote } from "./note-vocabulary.mjs";
 import { encodeAddresses, flattenPublishedAddresses } from "./address-values.mjs";
 import { EVENT_COLUMNS, EVENT_SORT_COLUMNS, eventRows } from "./event-rows.mjs";
+import { reckoningContext } from "./reckoning-markers.mjs";
 import { NAME_COLUMNS, namesRows } from "./name-rows.mjs";
 import {
     GLOSSARY_COLUMNS,
@@ -66,6 +67,7 @@ import { parseMarkdownFile } from "./helpers.mjs";
 import { sqlQueriesInMarkdown } from "./markdown-expressions.mjs";
 // The record accessors only — see `engine/index-records.mjs`.
 import { authoredFrontmatter, isNoteRecord, noteFile, sortKeysDeep } from "./index-records.mjs";
+import { nameSortOf } from "./name-sort.mjs";
 
 /** Rendered in a cell whose value is absent. */
 const EMPTY_CELL = "—";
@@ -438,11 +440,25 @@ export async function openNotesDatabase(
  */
 const WITH_STUBS_SCHEMA = "__with_stubs";
 
+/**
+ * The record with its `nameSort` stated: the declared `name.sort`, otherwise
+ * `name.full`. A record with no name has none.
+ *
+ * @param {object} record - An index record.
+ * @returns {object} The record, with `nameSort` where it has a name.
+ */
+function withNameSort(record) {
+    const key = nameSortOf(record);
+    return key === undefined ? record : { ...record, nameSort: key };
+}
+
 /**
  * Create the two relations an index is read through, and the ladder one of them
  * derives.
  *
- * **`entries` is every row**, stubs included, plus a derived `state` column:
+ * **`entries` is every row**, stubs included, plus a derived `nameSort` column
+ * (the note's `name.sort`, otherwise its `name.full`) and a derived `state`
+ * column:
  *
  * ```text
  * address IS NULL                 → stub
@@ -484,7 +500,7 @@ async function createRelations(connection, file, records, prefix = "", audience
         records
             .map((record) =>
                 JSON.stringify({
-                    record: sortKeysDeep(record),
+                    record: sortKeysDeep(withNameSort(record)),
                     visible: audience !== "public" || !isGmNote(record),
                 }),
             )
@@ -535,9 +551,8 @@ async function createRelations(connection, file, records, prefix = "", audience
  * @returns {Promise<void>}
  */
 async function createEventRelation(connection, file, records, prefix, audience) {
-    const rows = eventRows(
-        audience === "public" ? records.filter((record) => !isGmNote(record)) : records,
-    );
+    const visible = audience === "public" ? records.filter((record) => !isGmNote(record)) : records;
+    const rows = eventRows(visible, reckoningContext({ notes: records }));
     if (!rows.length) {
         const columns = EVENT_COLUMNS.map((column) => {
             const type = EVENT_SORT_COLUMNS.includes(column) ? "DOUBLE" : "VARCHAR";

package/githooks/pre-push

@@ -1,16 +1,16 @@
 #!/usr/bin/env sh
 #
 # Before pushing, run exactly what the Build & Test workflow runs — in a
-# container, over a clean export of HEAD — so a red GitHub check is something
+# container, over a clean export of HEAD — so a red CI check is something
 # you chose rather than something you discover.
 #
 # The steps are not listed here. `ci/ci-steps.mjs` reads them out of
-# `.github/workflows/build.yml`, because a hook holding its own copy of the
+# `.gitea/workflows/build.yml`, because a hook holding its own copy of the
 # command list is a second statement of one thing, and the copy is the one that
 # goes stale — silently, since running four of five steps still exits 0.
 #
 # **On push rather than at `gh pr create`**, because a push is where this
-# repository's work reaches GitHub: normally one, just before the pull request.
+# repository's work reaches the forge: normally one, just before the pull request.
 # Nothing to remember, no wrapper command, and no entry in package.json — the
 # hook is the whole mechanism.
 #
@@ -92,7 +92,7 @@ status=$?
 # 2 means the check could not run — no Docker — which is not the same as a
 # failure and must not stop the push. Whoever is pushing may not be the
 # maintainer, may be on a machine without Docker, and is entitled to open a
-# pull request; GitHub is what enforces the workflow. Said loudly, though: a
+# pull request; CI is what enforces the workflow. Said loudly, though: a
 # skipped check that reads like a passed one is how a guard loses its meaning.
 # 127 is "could not execute it at all" — no node on PATH, package not
 # installed. Infrastructure, not a verdict, so it is handled the same way.
@@ -104,6 +104,6 @@ fi
 
 if [ "$status" -ne 0 ]; then
     echo ""
-    echo "pre-push: refusing to push — GitHub would report the same failure."
+    echo "pre-push: refusing to push — CI would report the same failure."
     exit 1
 fi

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "23.12.3",
+    "version": "23.12.5",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",

package/types/content-config.d.mts

@@ -159,6 +159,11 @@ export type ResolvedPdfBook = {
      */
     id: string;
     title: string;
+    /**
+     * Names the book in another book's
+     * references; `""` when none is declared.
+     */
+    abbreviation: string;
     /**
      * `""` when none is declared.
      */

package/types/engine/content-index.d.mts

@@ -31,36 +31,6 @@ export function noteAddress(frontmatter: Record<string, any>, contentPackage: st
     slug: string;
     canonical: string;
 } | null;
-/**
- * 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: unknown): string | null;
 /**
  * A note's `name.aliases` reduced to printable 7-bit ASCII, in order.
  *
@@ -449,6 +419,7 @@ export type PreparedContentIndex = {
      */
     syntax?: import("./content-session.mjs").ContentSyntax | undefined;
 };
+import { asciiName } from "./name-sort.mjs";
 import { collectAnchors } from "./anchors.mjs";
 import { authoredFrontmatter } from "./index-records.mjs";
 import { DERIVED_KEYS } from "./index-records.mjs";
@@ -458,4 +429,4 @@ import { isStub } from "./index-records.mjs";
 import { noteFile } from "./index-records.mjs";
 import { recordPath } from "./index-records.mjs";
 import { sortKeysDeep } from "./index-records.mjs";
-export { collectAnchors, authoredFrontmatter, DERIVED_KEYS, isAssetRecord, isNoteRecord, isStub, noteFile, recordPath, sortKeysDeep };
+export { asciiName, collectAnchors, authoredFrontmatter, DERIVED_KEYS, isAssetRecord, isNoteRecord, isStub, noteFile, recordPath, sortKeysDeep };

package/types/engine/event-fields.d.mts

@@ -46,6 +46,17 @@ export function eventNoteIndex(records: Iterable<Record<string, any>>, { content
  * @returns {string} The printed date.
  */
 export function printEventDate(written: unknown, date: object | null, dates?: object): string;
+/**
+ * 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: unknown, date: object | null, dates?: object, calendar?: string): string;
 /**
  * One field of one event, as the text a reference prints, or why it cannot.
  *

package/types/engine/event-rows.d.mts

@@ -3,10 +3,13 @@
  *
  * @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: Iterable<Record<string, any>>): object[];
+export function eventRows(records: Iterable<Record<string, any>>, dates?: object): object[];
 /** The sort keys a row carries, after the event's own keys. */
 export const EVENT_SORT_COLUMNS: readonly string[];
+/** The printed dates a row carries, after the sort keys. */
+export const EVENT_TEXT_COLUMNS: readonly string[];
 /** Every column of the `events` relation, in order. */
 export const EVENT_COLUMNS: any;