@heroiclands/package-build 23.12.4 → 23.12.6

package/engine/note-calendars.mjs

@@ -0,0 +1,314 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * **The calendar a note's dates print in.** A note's calendar is the first of:
+ *
+ * 1. its own `data.calendar`, on any type;
+ * 2. its culture's calendar: the culture note its `data.culture` names,
+ *    resolved by these same rules;
+ * 3. for a `place`, its `data.parents`, each resolved by these same rules. Two
+ *    or more distinct calendars among them are an error at the place's
+ *    `data.parents`, fixed by stating `data.calendar` on the place;
+ * 4. the package's configured `defaultCalendar`;
+ * 5. otherwise none, and a date prints as it was written.
+ *
+ * Steps 2 and 3 take only a calendar some note states: a culture or parent
+ * that itself falls through to the default contributes nothing, so parents
+ * that all fall through give the default and raise no error. A note met again
+ * while it is being resolved — a cycle through `data.parents` or
+ * `data.culture` — contributes nothing either, and the chain goes on to the
+ * default.
+ *
+ * The content index writes the result onto each note record as
+ * `resolvedCalendar`, the calendar note's Address, and
+ * every reader of a note's calendar reads it from there: the event views, the
+ * `dateformat` helper and the infobox's dates.
+ *
+ * @module
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+import { canonicalKey, isAddressTuple, readCanonicalKey, renderAddress } from "./address.mjs";
+import { isAddressSegment } from "./address-charset.mjs";
+import { AddressLink } from "./address-values.mjs";
+import { formatDiagnostic, positionOfFrontmatterPath, positionOfYamlPath } from "./diagnostics.mjs";
+import { isNoteRecord, noteFile } from "./index-records.mjs";
+import { noteCalendarKey } from "./reckoning-markers.mjs";
+import { NOTE_SYSTEM } from "./systems.mjs";
+
+/** The configuration key naming the calendar of last resort. */
+export const DEFAULT_CALENDAR_KEY = "defaultCalendar";
+
+/**
+ * The canonical key an Address names, without any anchor.
+ *
+ * @param {unknown} value - A tuple, an {@link AddressLink}, or anything else.
+ * @returns {string|undefined} The key, or `undefined` for anything else.
+ */
+function addressKey(value) {
+    const tuple = value instanceof AddressLink ? value.target : value;
+    return isAddressTuple(tuple) ? renderAddress(tuple) : undefined;
+}
+
+/**
+ * Whether a record is a calendar note.
+ *
+ * @param {Record<string, any>|undefined} record - An index record.
+ * @returns {boolean} Whether it is a `lore` note with `subType: calendar`.
+ */
+function isCalendarNote(record) {
+    return record?.type === "lore" && String(record.subType ?? "").toLowerCase() === "calendar";
+}
+
+/**
+ * The canonical key of the calendar `defaultCalendar` names, or why it names none.
+ *
+ * @param {unknown} shortcode - The configured value.
+ * @param {string} contentPackage - The package the shortcode is read in.
+ * @param {(key: string) => Record<string, any>|undefined} recordOf - A local
+ *   note by canonical key.
+ * @returns {{key?: string, problem?: string}} The calendar, or the problem.
+ */
+function defaultCalendarKey(shortcode, contentPackage, recordOf) {
+    if (shortcode === undefined || shortcode === null) return {};
+    const named = String(shortcode);
+    const key =
+        isAddressSegment(named) ?
+            canonicalKey(contentPackage, NOTE_SYSTEM, "lore", named)
+        :   undefined;
+    if (key && isCalendarNote(recordOf(key))) return { key };
+    return {
+        problem:
+            `${DEFAULT_CALENDAR_KEY} ${named} names no calendar note in ${contentPackage}; ` +
+            `name the shortcode of a lore note with subType: calendar`,
+    };
+}
+
+/**
+ * Write each note's resolved calendar into its record, as `resolvedCalendar`.
+ *
+ * Reads each note's authored `data.calendar`, `data.culture` and
+ * `data.parents`, so it runs before the index writes a resolved culture over
+ * `data.culture`. A culture or parent in another package contributes the
+ * calendar its published entry states in `data.calendar`, and nothing else.
+ *
+ * @param {Array<Record<string, any>>} records - Index records, every Address a
+ *   tuple. Records that are not notes are passed over.
+ * @param {object} options - Options.
+ * @param {string} options.contentPackage - The package the records belong to.
+ * @param {string} [options.defaultCalendar] - The configured calendar of last
+ *   resort, a calendar note's shortcode.
+ * @param {string} [options.configFile] - The configuration file, where an
+ *   unknown `defaultCalendar` is reported.
+ * @param {string} [options.contentBase] - The content tree, for opening a note
+ *   to locate a finding.
+ * @param {(key: string) => Record<string, any>|undefined} [options.foreignRecord] -
+ *   Another package's entry for a canonical address.
+ * @param {object[]} [options.problems] - Receives each finding. Omitted, the
+ *   findings are collected and one Error lists them all.
+ * @param {Map<string, {raw: string}>} [options.parsed] - Notes already read, keyed by file.
+ * @returns {Array<Record<string, any>>} The same records.
+ * @throws {Error} When `problems` is omitted and anything is reported.
+ */
+export function resolveNoteCalendars(
+    records,
+    { contentPackage, defaultCalendar, configFile, contentBase, foreignRecord, problems, parsed },
+) {
+    const notes = new Map();
+    for (const record of records) {
+        if (!isNoteRecord(record) || !isAddressSegment(String(record.shortcode ?? ""))) continue;
+        const key = canonicalKey(contentPackage, NOTE_SYSTEM, record.type, record.shortcode);
+        if (!notes.has(key)) notes.set(key, record);
+    }
+    const findings = [];
+
+    const fallback = defaultCalendarKey(defaultCalendar, contentPackage, (key) => notes.get(key));
+    if (fallback.problem) {
+        const file = configFile ?? "package-build.config.yaml";
+        const source =
+            configFile && /\.ya?ml$/.test(configFile) && fs.existsSync(configFile) ?
+                fs.readFileSync(configFile, "utf8")
+            :   undefined;
+        findings.push({
+            file,
+            ...(source ? positionOfYamlPath(source, [DEFAULT_CALENDAR_KEY], { key: true }) : {}),
+            severity: "error",
+            message: fallback.problem,
+        });
+    }
+
+    const memo = new Map();
+    const inProgress = new Set();
+
+    /**
+     * The calendar some note states for a source Address, local or foreign.
+     *
+     * @param {unknown} value - A `data.culture` or `data.parents` Address.
+     * @returns {string|undefined} The calendar's canonical key.
+     */
+    const statedThrough = (value) => {
+        const key = addressKey(value);
+        if (!key) return undefined;
+        const tuple = value instanceof AddressLink ? value.target : value;
+        if (tuple.package === contentPackage) {
+            const record = notes.get(
+                canonicalKey(contentPackage, NOTE_SYSTEM, tuple.type, tuple.shortcode),
+            );
+            return record ? resolve(record) : undefined;
+        }
+        return addressKey(foreignRecord?.(key)?.data?.calendar);
+    };
+
+    /**
+     * Report parents that disagree.
+     *
+     * @param {Record<string, any>} record - The place.
+     * @param {Array<{key: string, via: unknown}>} distinct - The calendars and
+     *   the parent each came through.
+     */
+    const conflict = (record, distinct) => {
+        const file = contentBase ? noteFile(contentBase, record) : record.file?.path;
+        const raw =
+            parsed?.get(file)?.raw ??
+            (contentBase && fs.existsSync(file) ? fs.readFileSync(file, "utf8") : undefined);
+        let position = positionOfFrontmatterPath(raw, ["data", "parents"], { key: true });
+        if (position.line === undefined)
+            position = positionOfFrontmatterPath(raw, ["data"], { key: true });
+        const via = (value) => {
+            const tuple = value instanceof AddressLink ? value.target : value;
+            return tuple.package === contentPackage ? tuple.shortcode : addressKey(tuple);
+        };
+        const named = distinct.map(({ key, via: source }) => `${key} via ${via(source)}`);
+        findings.push({
+            file,
+            ...position,
+            severity: "error",
+            message:
+                `place ${record.shortcode}: data.parents resolve to different calendars ` +
+                `(${named.join(", ")}); state data.calendar`,
+        });
+    };
+
+    /**
+     * The calendar a note states through its own field, its culture or — for a
+     * place — its parents, ignoring the default.
+     *
+     * @param {Record<string, any>} record - The note.
+     * @returns {string|undefined} The calendar's canonical key.
+     */
+    const resolveRecord = (record) => {
+        const own = addressKey(record.data?.calendar);
+        if (own) return own;
+        const culture = statedThrough(record.data?.culture);
+        if (culture) return culture;
+        if (record.type !== "place") return undefined;
+        const parents = Array.isArray(record.data?.parents) ? record.data.parents : [];
+        const distinct = new Map();
+        for (const parent of parents) {
+            const calendar = statedThrough(parent);
+            if (calendar && !distinct.has(calendar)) distinct.set(calendar, parent);
+        }
+        if (distinct.size > 1) {
+            conflict(
+                record,
+                [...distinct].map(([key, via]) => ({ key, via })),
+            );
+            return undefined;
+        }
+        return distinct.keys().next().value;
+    };
+
+    /**
+     * A local note's stated calendar, memoised; a note already being resolved
+     * is a cycle and states nothing.
+     *
+     * @param {Record<string, any>} record - The note.
+     * @returns {string|undefined} The calendar's canonical key.
+     */
+    const resolve = (record) => {
+        if (memo.has(record)) return memo.get(record);
+        if (inProgress.has(record)) return undefined;
+        inProgress.add(record);
+        const result = resolveRecord(record);
+        inProgress.delete(record);
+        memo.set(record, result);
+        return result;
+    };
+
+    // Walked in address order, so which note of a cycle is met first is a fact
+    // about the content rather than about directory-read order.
+    const calendars = new Map();
+    for (const key of [...notes.keys()].sort())
+        calendars.set(key, resolve(notes.get(key)) ?? fallback.key);
+    // A note's second record — an item's documentation journal — is the same
+    // note, and reads in the same calendar.
+    for (const record of records) {
+        if (!isNoteRecord(record) || !isAddressSegment(String(record.shortcode ?? ""))) continue;
+        const calendar = calendars.get(
+            canonicalKey(contentPackage, NOTE_SYSTEM, record.type, record.shortcode),
+        );
+        if (calendar) record.resolvedCalendar = readCanonicalKey(calendar);
+        else delete record.resolvedCalendar;
+    }
+
+    findings.sort(
+        (a, b) =>
+            String(a.file).localeCompare(String(b.file), "en") ||
+            (a.line ?? 0) - (b.line ?? 0) ||
+            (a.column ?? 0) - (b.column ?? 0),
+    );
+    if (problems) problems.push(...findings);
+    else if (findings.length)
+        throw Object.assign(new Error(findings.map(formatDiagnostic).join("\n")), {
+            located: true,
+        });
+    return records;
+}
+
+/**
+ * The configuration file in a package root, where a configured value is
+ * reported.
+ *
+ * @param {string|undefined} rootDir - The package root.
+ * @param {readonly string[]} names - The file names a configuration may take.
+ * @returns {string|undefined} The first that exists.
+ */
+export function configFileIn(rootDir, names) {
+    if (!rootDir) return undefined;
+    for (const name of names) {
+        const file = path.join(rootDir, name);
+        if (fs.existsSync(file)) return file;
+    }
+    return undefined;
+}
+
+/**
+ * The calendar a note's dates print in: the one the content index resolved for
+ * it, where the reckoning context carries it, else the note's own
+ * `data.calendar`.
+ *
+ * @param {object|undefined} fm - The note's frontmatter.
+ * @param {{noteCalendars?: Map<string, string>}} [dates] - The reckoning context.
+ * @returns {string|undefined} The calendar's Address or shortcode.
+ */
+export function noteCalendar(fm, dates) {
+    const key = noteCalendarKey(fm);
+    const resolved = key ? dates?.noteCalendars?.get(key) : undefined;
+    if (resolved) return resolved;
+    const own = fm?.data?.calendar;
+    if (own === undefined || own === null || own === "") return undefined;
+    return addressKey(own) ?? String(own);
+}

package/engine/note-frontmatter.mjs

@@ -22,7 +22,7 @@ export {
 } from "./note-vocabulary.mjs";
 
 /** The name properties every note accepts, in display order. */
-export const NOTE_NAME_KEYS = Object.freeze(["full", "aliases"]);
+export const NOTE_NAME_KEYS = Object.freeze(["full", "aliases", "sort"]);
 
 /** Additional name components accepted by an individual character. */
 export const CHARACTER_NAME_KEYS = Object.freeze(["given", "clan"]);

package/engine/note-vocabulary.mjs

@@ -939,7 +939,7 @@ export const NOTE_TOP_LEVEL_FIELDS = Object.freeze([
     }),
     Object.freeze({
         name: "name",
-        describe: "The display names — a required `full`, and any `aliases`.",
+        describe: "The display names — a required `full`, and any `aliases` and `sort`.",
     }),
     Object.freeze({
         name: "type",
@@ -1030,6 +1030,17 @@ export const SHARED_DATA_FIELDS = Object.freeze([
         describe:
             "Deliberate cross-references in reading order, with optional glosses; shown on the site, in journals and in books.",
     }),
+    Object.freeze({
+        name: "calendar",
+        ...LINK,
+        ref: "lore",
+        accepts: Object.freeze(["lore"]),
+        check: checkCalendarChoice,
+        describe:
+            "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`.",
+    }),
     Object.freeze({
         name: "id",
         ...TEXT,
@@ -1596,14 +1607,6 @@ export const NOTE_VOCABULARY = Object.freeze({
                     "When the being was born — a date, or `unknown` where the birth is " +
                     "unrecorded. Absent, the being was never born.",
             },
-            {
-                name: "calendar",
-                ...LINK,
-                ref: "lore",
-                accepts: ["lore"],
-                check: checkCalendarChoice,
-                describe: "Calendar that displays this being's dates.",
-            },
             {
                 name: "died",
                 ...TEXT,
@@ -2281,14 +2284,6 @@ export const NOTE_VOCABULARY = Object.freeze({
         check: checkPlace,
         data: Object.freeze([
             EVENTS_FIELD,
-            {
-                name: "calendar",
-                ...LINK,
-                ref: "lore",
-                accepts: ["lore"],
-                check: checkCalendarChoice,
-                describe: "Calendar that displays this place's dates.",
-            },
             {
                 name: "demonym",
                 ...TEXT,

package/engine/page-lists.mjs

@@ -41,6 +41,7 @@
  * @module
  */
 
+import { nameSortKey } from "./name-sort.mjs";
 import { FENCE_LINE, parseHeaderArgs } from "./code-fences.mjs";
 import { booleanAttribute } from "./extension-attributes.mjs";
 import { isNoteRecord } from "./index-records.mjs";
@@ -195,8 +196,8 @@ export function findPageListBlocks(markdown) {
     return blocks;
 }
 
-/** A page's sort key, folded so a circumflex sorts with its letter. */
-const nameKey = (record) => String(record?.nameAscii ?? record?.name?.full ?? "").toLowerCase();
+/** A page's sort key: its `name.sort` or `name.full`, folded so a circumflex sorts with its letter. */
+const nameKey = (record) => nameSortKey(record).toLowerCase();
 
 /** The address a page is addressed by, as a stable tiebreak. */
 const slugKey = (record) => String(record?.address?.slug ?? "");

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.
@@ -125,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) =>
@@ -139,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));

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 = "?";
@@ -259,7 +260,7 @@ export function elsewhereFor({ entries, book, printed, table, seeAlso = false })
         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
@@ -1166,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`;
 }
 
@@ -1295,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;
             }
@@ -1411,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)
@@ -1441,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}]`;
@@ -1452,6 +1467,10 @@ function renderLink(href, inner, ctx) {
  * 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, or between the abbreviation and the page,
  * does not break, so a number never starts a line of its own.
  *
@@ -1459,13 +1478,16 @@ function renderLink(href, inner, ctx) {
  * @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) {
-    if (away.abbreviation) {
-        return `${inner} (${escapeTypst(away.abbreviation)}~p${away.page})`;
-    }
-    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})`;
 }
 
 /**
@@ -1702,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" +
             "}",
@@ -2030,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 ?? "";