@heroiclands/package-build 23.12.4 → 23.12.5

package/engine/generated-sections.mjs

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

package/engine/holdings.mjs

@@ -24,13 +24,14 @@ import { isAddressTuple, ownDocumentSystem, parseAddress, renderAddress } from "
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
 import { readCanonicalKey } from "./content-address.mjs";
 
-/** @typedef {{title:string,url?:string,address:string,type:string,subType?:string}} HoldingsEntry */
+/** @typedef {{title:string,sort?:string,url?:string,address:string,type:string,subType?:string}} HoldingsEntry */
 /**
  * @typedef {object} HoldingsNode
  * @property {string} shortcode
  * @property {"place"|"affiliation"} type
  * @property {string} [subType]
  * @property {string} title
+ * @property {string} [sort] The note's `name.sort`; the list files by it in place of `title`.
  * @property {string} [url]
  * @property {string} [package] Owning content package.
  * @property {string} [system] Own document system.
@@ -108,6 +109,7 @@ function listed(node) {
 function entryOf(node) {
     return {
         title: node.title,
+        ...(node.sort ? { sort: node.sort } : {}),
         ...(listed(node) ? { url: node.url } : {}),
         address: ownKey(node),
         type: node.type,
@@ -118,7 +120,7 @@ function entryOf(node) {
 function bySubTypeThenTitle(a, b) {
     return (
         (a.subType ?? "").localeCompare(b.subType ?? "", "en") ||
-        a.title.localeCompare(b.title, "en")
+        (a.sort ?? a.title).localeCompare(b.sort ?? b.title, "en")
     );
 }
 
@@ -141,6 +143,7 @@ export function holdingsNode(
         type,
         subType: fm.subType == null ? undefined : String(fm.subType),
         title,
+        ...(typeof fm.name?.sort === "string" && fm.name.sort ? { sort: fm.name.sort } : {}),
         url,
         ...(pkg ? { package: pkg } : {}),
         ...(system ? { system } : {}),
@@ -173,6 +176,9 @@ export function foreignHoldingsNodes(foreignIndex) {
             type,
             subType: entry.subType == null ? undefined : String(entry.subType),
             title: String(entry.name ?? tuple.shortcode),
+            ...(typeof entry.nameSort === "string" && entry.nameSort ?
+                { sort: entry.nameSort }
+            :   {}),
             url: entry.url,
             parents:
                 type === "place" ?

package/engine/infobox-render.mjs

@@ -296,9 +296,14 @@ function entryToTypst(entry, link) {
 }
 
 /**
- * One section as Typst, whole and unbreakable.
+ * One section as Typst.
  *
- * `lead` rides **inside** the block rather than above it. A panel breaks
+ * A stat grid is whole and unbreakable. A section of rows or run-in lists may
+ * break between its rows, so a section taller than the space left on a page
+ * continues on the next one instead of running past the page's foot; each row
+ * stays whole, and the section's label and `lead` stay with its first row.
+ *
+ * `lead` rides **inside** the section rather than above it. A panel breaks
  * between its sections, and a title sitting outside the first one is a break
  * the panel is allowed to take — which leaves the heading and a rule stranded
  * at the foot of a page with nothing under them.
@@ -309,8 +314,9 @@ function entryToTypst(entry, link) {
  * @returns {string} Typst markup.
  */
 function sectionToTypst(section, link, lead = "") {
-    const body = lead ? [lead] : [];
-    if (section.label) body.push(`#infobox-head[${escapeTypst(section.label)}]`);
+    const head = lead ? [lead] : [];
+    if (section.label) head.push(`#infobox-head[${escapeTypst(section.label)}]`);
+    const body = [];
 
     if (section.layout === "rows") {
         for (const row of section.rows ?? []) {
@@ -346,7 +352,12 @@ function sectionToTypst(section, link, lead = "") {
         }
     }
 
-    return `#block(breakable: false)[\n${body.join("\n")}\n]`;
+    if (section.layout === "grid" || body.length < 2)
+        return `#block(breakable: false)[\n${[...head, ...body].join("\n")}\n]`;
+    const [first, ...rest] = body;
+    const kept = `#block(breakable: false)[\n${[...head, first].join("\n")}\n]`;
+    const rows = rest.map((row) => `#block(breakable: false)[${row}]`);
+    return `#block(breakable: true)[\n${[kept, ...rows].join("\n")}\n]`;
 }
 
 /**

package/engine/infobox.mjs

@@ -593,6 +593,27 @@ export function valueKindOf(field, value) {
     return Array.isArray(value) ? "list" : "text";
 }
 
+/**
+ * A number as a reader reads it in a profile: under a million in full with
+ * thousands separators (`850`, `12,500`), and from a million up in words with
+ * at most one decimal (`11 million`, `1.2 million`, `3 billion`). Every figure
+ * the setting gives at that scale is an estimate, and the words say so.
+ * Decimals below a million keep the digits they were written with.
+ *
+ * @param {number} value - The number.
+ * @returns {string} The text the row shows.
+ */
+export function formatQuantity(value) {
+    const n = Number(value);
+    if (!Number.isFinite(n)) return String(value);
+    const size = Math.abs(n);
+    if (size < 1e6) return n.toLocaleString("en-US", { maximumFractionDigits: 20 });
+    // A figure that rounds up to a thousand million is a billion.
+    const [scale, word] = size < 999.95e6 ? [1e6, "million"] : [1e9, "billion"];
+    const scaled = Math.round((n / scale) * 10) / 10;
+    return `${scaled.toLocaleString("en-US", { maximumFractionDigits: 1 })} ${word}`;
+}
+
 /**
  * Build one row's value, resolving whatever the kind says is a reference.
  *
@@ -616,7 +637,7 @@ function rowValue(kind, raw, resolve, hint, verbatim = false) {
     if (kind === "list") {
         return (Array.isArray(raw) ? raw : [raw]).filter(hasValue).map((v) => shown(v));
     }
-    if (kind === "number") return raw;
+    if (kind === "number") return formatQuantity(raw);
     return shown(raw);
 }
 
@@ -904,7 +925,7 @@ function declaredKeyRows(fields, raw) {
             (inner.kind === "number" || inner.kind === "integer") &&
             Number.isFinite(Number(value))
         ) {
-            rows.push({ label, kind: "number", value: Number(value) });
+            rows.push({ label, kind: "number", value: formatQuantity(Number(value)) });
         } else {
             rows.push({ label, kind: "text", value: shown(value) });
         }

package/engine/literature-works.mjs

@@ -31,11 +31,12 @@ import { AddressLink } from "./address-values.mjs";
 import { readCanonicalKey } from "./content-address.mjs";
 import { LITERATURE_SUBTYPE } from "./literature-notes.mjs";
 
-/** @typedef {{title: string, url?: string, address: string, form?: string}} WorkEntry */
+/** @typedef {{title: string, sort?: string, url?: string, address: string, form?: string}} WorkEntry */
 /**
  * @typedef {object} WorksNode
  * @property {string} key Own Address, normalized to the `note` system.
  * @property {string} title
+ * @property {string} [sort] The note's `name.sort`; the list files by it in place of `title`.
  * @property {string} [url] Absent for a note that publishes no page.
  * @property {string} [package] Owning content package.
  * @property {string} [form] A work's `data.form`.
@@ -79,6 +80,7 @@ export function worksNode(fm, { title, url, package: pkg }) {
     return {
         key: renderAddress({ package: pkg ?? "local", system: "note", type, shortcode }),
         title,
+        ...(typeof fm.name?.sort === "string" && fm.name.sort ? { sort: fm.name.sort } : {}),
         ...(url ? { url } : {}),
         ...(pkg ? { package: pkg } : {}),
         ...(work && typeof data.form === "string" && data.form ? { form: data.form } : {}),
@@ -107,6 +109,9 @@ export function foreignWorksNodes(foreignIndex) {
         out.push({
             key: renderAddress({ ...tuple, system: "note" }),
             title: String(entry.name ?? tuple.shortcode),
+            ...(typeof entry.nameSort === "string" && entry.nameSort ?
+                { sort: entry.nameSort }
+            :   {}),
             ...(entry.url ? { url: entry.url } : {}),
             package: tuple.package,
             ...(typeof entry.form === "string" && entry.form ? { form: entry.form } : {}),
@@ -149,6 +154,7 @@ export function worksPages(nodes, { types }) {
             if (!block) lists.set(target.url, (block = { works: [] }));
             block.works.push({
                 title: work.title,
+                ...(work.sort ? { sort: work.sort } : {}),
                 ...(work.url ? { url: work.url } : {}),
                 address: work.key,
                 ...(work.form ? { form: work.form } : {}),
@@ -156,6 +162,6 @@ export function worksPages(nodes, { types }) {
         }
     }
     for (const block of lists.values())
-        block.works.sort((a, b) => a.title.localeCompare(b.title, "en"));
+        block.works.sort((a, b) => (a.sort ?? a.title).localeCompare(b.sort ?? b.title, "en"));
     return lists;
 }

package/engine/metadata-index.mjs

@@ -445,6 +445,9 @@ export function loadForeignIndexes(config, localPackages, bases = PACKAGE_BASE)
             const foundry = record.foundry?.[parts.system];
             index.set(key, {
                 name: record.name?.full ?? record.name,
+                ...(typeof record.name?.sort === "string" && record.name.sort ?
+                    { nameSort: record.name.sort }
+                :   {}),
                 aliases: record.name?.aliases,
                 // Absent where the package publishes no page for it. A consumer
                 // must tolerate that rather than invent an href, exactly as it

package/engine/name-sort.mjs

@@ -0,0 +1,91 @@
+/*
+ * 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 key a name-ordered list files a note under, and the ASCII fold ordering
+ * compares it on. A leaf module, so every list that orders notes by name can
+ * read the key without importing the content index.
+ *
+ * @module
+ */
+
+import unidecode from "unidecode";
+
+/**
+ * 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;
+}
+
+/**
+ * The name a note files under: its `name.sort` when it declares one, otherwise
+ * its `name.full`.
+ *
+ * @param {unknown} record - An index record or a note's frontmatter.
+ * @returns {string|undefined} The unfolded key, or `undefined` for a record
+ *   with no name.
+ */
+export function nameSortOf(record) {
+    const name = /** @type {any} */ (record)?.name;
+    for (const candidate of [name?.sort, name?.full]) {
+        if (typeof candidate === "string" && candidate.trim()) return candidate;
+    }
+    return undefined;
+}
+
+/**
+ * The key a name-ordered list compares notes on: {@link nameSortOf} folded to
+ * printable ASCII by {@link asciiName}, so an accented sort key files beside
+ * its base letters. Case is left for the caller, which decides whether its
+ * comparison ignores it.
+ *
+ * @param {unknown} record - An index record or a note's frontmatter.
+ * @returns {string} The key, or "" for a record with no name.
+ */
+export function nameSortKey(record) {
+    const key = nameSortOf(record);
+    if (key === undefined) return "";
+    return asciiName(key) ?? key;
+}

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",

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 ?? "";

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) {