@heroiclands/package-build 23.12.7 → 23.13.0

package/engine/site-preview.mjs

@@ -18,10 +18,10 @@ import footnotePlugin from "markdown-it-footnote";
 import deflistPlugin from "markdown-it-deflist";
 import { dictionaryListPlugin } from "./definition-list.mjs";
 import Handlebars from "handlebars";
-import matter from "gray-matter";
+import { readMatter } from "./note-matter.mjs";
 import { ALERT_TYPES, alertMarkdownPlugin, scanAlerts } from "./content-alerts.mjs";
 import { spanMarkdownPlugin } from "./content-spans.mjs";
-import { scanPoetry, poetryStanzas } from "./content-poetry.mjs";
+import { scanVerse, verseStanzas } from "./content-verse.mjs";
 import { scanFigures } from "./content-figures.mjs";
 import { scanBlocks } from "./content-blocks.mjs";
 import { splitHeadingAttributes } from "./heading-attributes.mjs";
@@ -358,7 +358,7 @@ function parserFor(fm, findings, file) {
             const close = new state.Token("paragraph_close", "p", -1);
             state.tokens.splice(i + 1, 0, open, title, close);
         }
-        const poetry = scanPoetry(state.src).blocks;
+        const verse = scanVerse(state.src).blocks;
         const localFigures = scanFigures(state.src).figures;
         for (const fig of localFigures) if (fig.id) figures.set(fig.id, fig);
         for (const token of state.tokens) {
@@ -366,10 +366,10 @@ function parserFor(fm, findings, file) {
                 token.meta = {
                     ...token.meta,
                     source: lines.slice(token.map[0], token.map[1]).join("\n"),
-                    poem: poetry.find((poem) => poem.start === token.map[0]),
+                    poem: verse.find((poem) => poem.start === token.map[0]),
                 };
         }
-        // Poetry must become inline tokens before footnote collection, so a
+        // Verse must become inline tokens before footnote collection, so a
         // definition outside the fence remains visible to a verse reference.
         for (let i = state.tokens.length - 1; i >= 0; i--) {
             const token = state.tokens[i];
@@ -382,22 +382,22 @@ function parserFor(fm, findings, file) {
                 replacement.push(part);
                 return part;
             };
-            push("hl_preview_poetry_open", "div", 1, [["class", "poetry"]]).map = token.map;
-            for (const stanza of poetryStanzas(poem.body)) {
+            push("hl_preview_verse_open", "div", 1, [["class", "verse"]]).map = token.map;
+            for (const stanza of verseStanzas(poem.body)) {
                 push("paragraph_open", "p", 1);
                 stanza.forEach(({ text, level }, row) => {
                     if (row) push("hardbreak", "br", 0);
-                    push("hl_preview_poetry_line_open", "span", 1, [
-                        ["class", `poetry-line i${level}`],
+                    push("hl_preview_verse_line_open", "span", 1, [
+                        ["class", `verse-line i${level}`],
                     ]);
                     const line = push("inline", "", 0);
                     line.content = text;
                     line.children = [];
-                    push("hl_preview_poetry_line_close", "span", -1);
+                    push("hl_preview_verse_line_close", "span", -1);
                 });
                 push("paragraph_close", "p", -1);
             }
-            push("hl_preview_poetry_close", "div", -1);
+            push("hl_preview_verse_close", "div", -1);
             state.tokens.splice(i, 1, ...replacement);
         }
         // Work backwards so figure ranges and heading removals retain source maps.
@@ -583,7 +583,7 @@ export function renderPreview(
     let frontmatter = {},
         body = String(text ?? "");
     try {
-        const parsed = matter(body);
+        const parsed = readMatter(body);
         frontmatter =
             parsed.data && typeof parsed.data === "object" && !Array.isArray(parsed.data) ?
                 structuredClone(parsed.data)
@@ -665,7 +665,7 @@ export function previewStyles() {
 .hl-preview .alert-warning { --hl-accent:var(--hl-warning); --hl-alert-bg:var(--hl-warning-bg); }
 .hl-preview .alert .alert-title { color:var(--hl-accent); font-weight:700; opacity:1; }
 .hl-preview .alert .alert-icon { width:1em; height:1em; margin-right:.5em; vertical-align:-.1em; color:var(--hl-accent); fill:currentColor; }
-.hl-preview .poetry-line { white-space:pre-wrap; }
-${Array.from({ length: 9 }, (_, n) => `.hl-preview .poetry-line.i${n} { padding-left:${n * 2}em; }`).join("\n")}
+.hl-preview .verse-line { white-space:pre-wrap; }
+${Array.from({ length: 9 }, (_, n) => `.hl-preview .verse-line.i${n} { padding-left:${n * 2}em; }`).join("\n")}
 `;
 }

package/engine/sql-tables.mjs

@@ -28,6 +28,7 @@
 
 import { parseAddress, readCanonicalKey, renderAddress, isAddressTuple } from "./address.mjs";
 import { collectAnchors } from "./anchors.mjs";
+import { keyCaseCollisionDiagnostics } from "./key-case-collisions.mjs";
 import { expandContentTables } from "./content-tables.mjs";
 import { NOTE_VOCABULARY, isGmNote } from "./note-vocabulary.mjs";
 import { encodeAddresses, flattenPublishedAddresses } from "./address-values.mjs";
@@ -260,12 +261,14 @@ export function findSqlBlocks(markdown) {
  * @param {object} [opts.addressContext] - Address resolution context.
  * @param {"all"|"public"} [opts.audience] - Whether to exclude GM notes from
  *   local and dependency relations.
+ * @param {string} [opts.contentBase] - The directory the records' paths are
+ *   relative to, so a refused key is reported at its file and line.
  * @returns {Promise<{query: (sql: string) => Promise<object[]>,
  *   close: () => Promise<void>}>} The open database.
  */
 export async function openNotesDatabase(
     records,
-    { dir, dependencies = [], addressContext, audience = "all" } = {},
+    { dir, dependencies = [], addressContext, audience = "all", contentBase } = {},
 ) {
     const { DuckDBInstance } = await import("@duckdb/node-api");
     const base = dir ?? fs.mkdtempSync(path.join(os.tmpdir(), "content-sql-"));
@@ -276,7 +279,20 @@ export async function openNotesDatabase(
     const instance = await DuckDBInstance.create(":memory:");
     const connection = await instance.connect();
     await connection.run("SET threads=1");
-    await createRelations(connection, jsonl, encoded, "", audience);
+    try {
+        await createRelations(connection, jsonl, encoded, "", audience);
+    } catch (err) {
+        // DuckDB names the clashing key but not the notes that spell it.
+        if (/Duplicate name ".*" in struct/.test(String(err?.message))) {
+            const lines = keyCaseCollisionDiagnostics(records, { contentBase });
+            if (lines.length) {
+                const located = new Error(lines.join("\n"));
+                /** @type {any} */ (located).located = true;
+                throw located;
+            }
+        }
+        throw err;
+    }
     await createEventRelation(connection, path.join(base, "events.jsonl"), encoded, "", audience);
     await createNameRelation(connection, path.join(base, "names.jsonl"), encoded, "", audience);
     await createRunRelation(connection, path.join(base, "runs.jsonl"), encoded, "", audience);
@@ -630,7 +646,7 @@ async function createNameRelation(connection, file, records, prefix, audience) {
 }
 
 /**
- * Create the `runs` relation: one row per span, div and poetry fence an own
+ * Create the `runs` relation: one row per span, div and verse fence an own
  * note marks with `lang=`, `font=` or `map=`, with the columns
  * {@link module:engine/run-rows.RUN_COLUMNS} names. The columns are declared
  * rather than inferred, so every value stays a string and none becomes a
@@ -1732,6 +1748,7 @@ export async function prepareTreeSqlTables(
         (await openNotesDatabase(allRecords, {
             dependencies: await cachedDependencies(config),
             audience,
+            contentBase,
         }));
     try {
         const generated = await generatedSectionsFor(db, indexRecords, contentBase, {

package/engine/web-wikilinks.mjs

@@ -234,7 +234,7 @@ const FRONTMATTER_WIKILINK = new RegExp(WIKILINK.source, "g");
  * Values are read from the *parsed* frontmatter, so a `[[` inside a YAML comment
  * is not a hit, and every hit can be named by the path a reader would look at.
  *
- * @param {unknown} fm - Parsed frontmatter, as `gray-matter` returns it.
+ * @param {unknown} fm - Parsed frontmatter, as `readMatter` returns it.
  * @returns {Array<{path: string, link: string}>} In reading order; `path` is the
  *   dotted key path of the offending value (`government.summary`, `aliases.1`).
  */

package/engine/word-forms.mjs

@@ -0,0 +1,349 @@
+/*
+ * 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 regular forms a language's own rules derive from its lexicon.** Each
+ * rule a language note states in machine-readable form gives a lexicon word
+ * further forms, and nothing else does:
+ *
+ * - **the noun plural**: `data.grammar.plural`, or the word's own `plural`;
+ * - **the verb pattern**: a verb's citation form with one ending of
+ *   `data.grammar.verbs.persons`, which takes the place of a closing
+ *   `data.grammar.verbs.replaces` where the pattern states one (see
+ *   {@link module:engine/verb-pattern.verbForm});
+ * - **a replacing suffix**: a suffix of `data.affixes` that states `replaces`,
+ *   or its `front` form, on a word whose class base its `attachesTo` names,
+ *   or on any word where it states none: `vowel` takes the place of a closing
+ *   vowel (a letter whose base is `a`, `e`, `i`, `o` or `u`), letters take the
+ *   place of those letters, and a stem closing otherwise takes the suffix
+ *   whole. An affix that states no `replaces` derives nothing here;
+ * - **agreement**: a word whose class base `data.grammar.agreement.classes`
+ *   names, closing on one of `data.grammar.agreement.endings` (the longest
+ *   that leaves a stem), also takes each other ending in its place, and each
+ *   of those forms and the word itself takes the plural the
+ *   `data.grammar.plural` rule gives;
+ * - **participles**: a verb closing on one of `data.grammar.participles.root`
+ *   (the longest that leaves a root) drops it, and each suffix of `data.affixes`
+ *   that `data.grammar.participles.affixes` names, by its `form`, attaches to
+ *   the root as its `replaces` says, or whole where it states none. A
+ *   participle closing on an agreement ending agrees.
+ *
+ * The mapped-run word check ({@link module:engine/run-words}) and
+ * `package-build lexicon --derived` both read {@link derivedForms}, so what
+ * the command lists is what the check accepts.
+ *
+ * @module
+ */
+
+import { pluralByRule, pluralOf } from "./dictionary-rows.mjs";
+import { replaceClosing, verbForm, verbPattern } from "./verb-pattern.mjs";
+import { parseWordClass } from "./word-classes.mjs";
+import { WORD } from "./word-pattern.mjs";
+
+/** Whether a value is a plain map. */
+const isMap = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+/** A list value, or an empty one. */
+const listOf = (value) => (Array.isArray(value) ? value : []);
+
+/** The characters a compound is split at. */
+const JOINS = /[–-]/u;
+
+/**
+ * A word as it is compared: NFC, lowercase, `’` read as `'`.
+ *
+ * @param {string} word - The word.
+ * @returns {string} Its folded form.
+ */
+export function foldWord(word) {
+    return word.normalize("NFC").toLowerCase().replace(/’/gu, "'");
+}
+
+/** Whether a character is a vowel: its base letter is a, e, i, o or u. */
+const isVowel = (char) => /^[aeiou]/iu.test(char.normalize("NFD"));
+
+/**
+ * Add a text's words to a set, each whole and each part of a compound.
+ *
+ * @param {Set<string>} set - The set.
+ * @param {string} text - A form or a name.
+ */
+export function addWords(set, text) {
+    for (const [word] of text.matchAll(WORD)) {
+        const folded = foldWord(word);
+        set.add(folded);
+        for (const part of folded.split(JOINS)) if (part) set.add(part);
+    }
+}
+
+/**
+ * The form a suffix makes of a stem.
+ *
+ * @param {string} stem - The stem, folded.
+ * @param {string} suffix - The suffix, folded, with no hyphen.
+ * @param {string|undefined} replaces - The affix's `replaces`; none adds the
+ *   suffix whole.
+ * @returns {string} The derived form.
+ */
+function attach(stem, suffix, replaces) {
+    if (replaces === "vowel") {
+        const last = Array.from(stem).at(-1);
+        return last !== undefined && isVowel(last) ?
+                stem.slice(0, -last.length) + suffix
+            :   stem + suffix;
+    }
+    return replaceClosing(stem, suffix, replaces === undefined ? undefined : foldWord(replaces));
+}
+
+/**
+ * An affix's suffixes: its `form` and its `front` form, each written `-x`,
+ * folded and without the hyphen.
+ *
+ * @param {Record<string, any>} affix - One `data.affixes` entry.
+ * @returns {string[]} The suffixes.
+ */
+function suffixesOf(affix) {
+    const out = [];
+    for (const written of [affix.form, affix.front]) {
+        if (typeof written !== "string") continue;
+        const form = foldWord(written.trim());
+        if (!/^[-–]/u.test(form) || /[-–]$/u.test(form)) continue;
+        const suffix = form.replace(/^[-–]+/u, "");
+        if (suffix) out.push(suffix);
+    }
+    return out;
+}
+
+/**
+ * The suffixes a language's affixes state `replaces` for, each with the class
+ * bases its `attachesTo` names.
+ *
+ * @param {Record<string, any>} data - The language note's `data`.
+ * @returns {Array<{suffix: string, replaces: string, classes: ReadonlySet<string>|undefined}>}
+ *   The suffixes, folded; `classes` is `undefined` where the affix attaches to
+ *   every class.
+ */
+function replacingSuffixes(data) {
+    const out = [];
+    for (const affix of listOf(data.affixes)) {
+        if (!isMap(affix) || typeof affix.replaces !== "string") continue;
+        const classes =
+            Array.isArray(affix.attachesTo) ?
+                new Set(
+                    affix.attachesTo
+                        .filter((item) => typeof item === "string")
+                        .map((item) => item.trim()),
+                )
+            :   undefined;
+        for (const suffix of suffixesOf(affix))
+            out.push({ suffix, replaces: affix.replaces, classes });
+    }
+    return out;
+}
+
+/**
+ * The strings of a list, trimmed and folded, keeping those with letters.
+ *
+ * @param {unknown} value - The list.
+ * @returns {string[]} The strings.
+ */
+const foldedStrings = (value) =>
+    listOf(value)
+        .filter((item) => typeof item === "string" && item.trim())
+        .map((item) => foldWord(item.trim()));
+
+/**
+ * A language's agreement rule, as derivation reads it.
+ *
+ * @typedef {object} Agreement
+ * @property {ReadonlySet<string>} classes - The class bases that agree.
+ * @property {readonly string[]} endings - The endings, folded, longest first.
+ */
+
+/**
+ * Read a language's `data.grammar.agreement`.
+ *
+ * @param {unknown} value - The authored value.
+ * @returns {Agreement|undefined} The rule, or `undefined` where none is stated
+ *   in full.
+ */
+function agreementOf(value) {
+    if (!isMap(value)) return undefined;
+    const classes = listOf(value.classes).filter((item) => typeof item === "string");
+    const endings = [
+        ...new Set(
+            listOf(value.endings)
+                .filter((item) => typeof item === "string")
+                .map((item) => foldWord(item.trim())),
+        ),
+    ];
+    if (!classes.length || endings.length < 2) return undefined;
+    return {
+        classes: new Set(classes.map((item) => item.trim())),
+        endings: endings.sort((a, b) => b.length - a.length),
+    };
+}
+
+/**
+ * The forms an agreeing word takes beside its own.
+ *
+ * @param {string} form - The word, folded.
+ * @param {Agreement} agreement - The rule.
+ * @param {Record<string, any>|undefined} grammar - The language's grammar,
+ *   for its plural rule.
+ * @returns {string[]} The forms; none where the word closes on no ending.
+ */
+function agreeingForms(form, agreement, grammar) {
+    const ending = agreement.endings.find((one) => form.length > one.length && form.endsWith(one));
+    if (ending === undefined) return [];
+    const stem = form.slice(0, form.length - ending.length);
+    const singulars = agreement.endings.map((one) => stem + one);
+    const out = singulars.filter((one) => one !== form);
+    for (const one of singulars) {
+        const plural = pluralByRule(one, grammar);
+        if (plural) out.push(foldWord(plural));
+    }
+    return out;
+}
+
+/**
+ * A language's participle rule, as derivation reads it.
+ *
+ * @typedef {object} Participles
+ * @property {readonly string[]} root - The root endings, folded, longest
+ *   first.
+ * @property {Array<{suffix: string, replaces: string|undefined}>} suffixes -
+ *   The participle suffixes, folded.
+ */
+
+/**
+ * Read a language's `data.grammar.participles` against its affixes.
+ *
+ * @param {unknown} value - The authored value.
+ * @param {Record<string, any>} data - The language note's `data`.
+ * @returns {Participles|undefined} The rule, or `undefined` where it names no
+ *   root ending or no suffix the affixes state.
+ */
+function participlesOf(value, data) {
+    if (!isMap(value)) return undefined;
+    const root = [...new Set(foldedStrings(value.root))].sort((a, b) => b.length - a.length);
+    const named = new Set(
+        listOf(value.affixes)
+            .filter((item) => typeof item === "string")
+            .map((item) => item.trim()),
+    );
+    const suffixes = [];
+    for (const affix of listOf(data.affixes)) {
+        if (!isMap(affix) || typeof affix.form !== "string" || !named.has(affix.form.trim()))
+            continue;
+        const replaces = typeof affix.replaces === "string" ? affix.replaces : undefined;
+        for (const suffix of suffixesOf(affix)) suffixes.push({ suffix, replaces });
+    }
+    if (!root.length || !suffixes.length) return undefined;
+    return { root, suffixes };
+}
+
+/**
+ * The participles of a verb.
+ *
+ * @param {string} citation - The citation form, folded.
+ * @param {Participles} participles - The rule.
+ * @returns {string[]} The participles; none where the verb closes on no root
+ *   ending.
+ */
+function participleForms(citation, participles) {
+    const ending = participles.root.find(
+        (one) => citation.length > one.length && citation.endsWith(one),
+    );
+    if (ending === undefined) return [];
+    const root = citation.slice(0, citation.length - ending.length);
+    return participles.suffixes.map(({ suffix, replaces }) => attach(root, suffix, replaces));
+}
+
+/**
+ * One form a rule derives from a lexicon word.
+ *
+ * @typedef {object} DerivedForm
+ * @property {string} form - The form, folded.
+ * @property {Record<string, any>} word - The `data.words` entry it comes from.
+ */
+
+/**
+ * Every form the language's rules derive from its lexicon words, in
+ * `data.words` order, each once, leaving out a form that is a lexicon word.
+ *
+ * @param {Record<string, any>|undefined} data - The language note's `data`.
+ * @returns {DerivedForm[]} The forms.
+ */
+export function derivedForms(data) {
+    const words = listOf(data?.words).filter(
+        (word) => isMap(word) && typeof word.form === "string",
+    );
+    const grammar = isMap(data?.grammar) ? data.grammar : undefined;
+    const verbs = verbPattern(grammar?.verbs);
+    const replaces = verbs?.replaces === undefined ? undefined : foldWord(verbs.replaces);
+    const suffixes = replacingSuffixes(data ?? {});
+    const agreement = agreementOf(grammar?.agreement);
+    const participles = participlesOf(grammar?.participles, data ?? {});
+    const seen = new Set(words.map((word) => foldWord(word.form)));
+    const out = [];
+    for (const word of words) {
+        const add = (form) => {
+            const folded = foldWord(form);
+            if (!folded || seen.has(folded)) return;
+            seen.add(folded);
+            out.push({ form: folded, word });
+        };
+        const folded = foldWord(word.form);
+        const base = parseWordClass(word.class).base;
+        const plural = pluralOf(word, grammar);
+        if (plural) add(plural);
+        if (verbs && base === "v")
+            for (const { ending } of verbs.endings)
+                add(verbForm(folded, foldWord(ending), replaces));
+        const attaching = suffixes.filter(
+            ({ classes }) => classes === undefined || (base !== undefined && classes.has(base)),
+        );
+        if (attaching.length)
+            for (const [stem] of word.form.matchAll(WORD)) {
+                const one = foldWord(stem);
+                for (const { suffix, replaces: closing } of attaching)
+                    add(attach(one, suffix, closing));
+            }
+        if (agreement && base !== undefined && agreement.classes.has(base))
+            for (const form of agreeingForms(folded, agreement, grammar)) add(form);
+        if (participles && base === "v")
+            for (const participle of participleForms(folded, participles)) {
+                add(participle);
+                if (agreement)
+                    for (const form of agreeingForms(participle, agreement, grammar)) add(form);
+            }
+    }
+    return out;
+}
+
+/**
+ * The words a language note accepts of its own: its forms, and what its rules
+ * derive from them (see {@link derivedForms}), each whole and each part of a
+ * compound.
+ *
+ * @param {Record<string, any>} data - The language note's `data`.
+ * @returns {Set<string>} The words, folded.
+ */
+export function lexiconWords(data) {
+    const accepted = new Set();
+    for (const word of listOf(data?.words))
+        if (isMap(word) && typeof word.form === "string") addWords(accepted, word.form);
+    for (const { form } of derivedForms(data)) addWords(accepted, form);
+    return accepted;
+}

package/engine/word-terms.mjs

@@ -368,6 +368,15 @@ export const AFFIX_FIELDS = Object.freeze([
             "What it takes the place of at the close of the stem: `vowel` for any closing " +
             "vowel, or the letters it replaces; added to the whole stem where absent.",
     }),
+    Object.freeze({
+        name: "attachesTo",
+        kind: "list",
+        shape: "a list of word classes, such as `[n, adj]`",
+        entries: Object.freeze({ kind: "string", shape: "a word class, such as `n`" }),
+        describe:
+            "The word classes it attaches to, by their base; every class where absent. A " +
+            "suffix stating `replaces` derives forms of these classes' words alone.",
+    }),
     Object.freeze({
         name: "lengthens",
         kind: "boolean",

package/hugo-theme/static/css/style.css

@@ -1378,33 +1378,109 @@ a.tag:hover {
 }
 
 /* Verse lines are hard breaks in the markup; paragraphs mark stanzas. */
-.single-content .poetry {
+.single-content .verse {
   margin: 1.5rem 0;
   line-height: 1.7;
 }
 
-.single-content .poetry p {
+.single-content .verse p {
   margin: 0;
 }
 
-.single-content .poetry p + p {
+.single-content .verse p + p {
   margin-top: 1em;
 }
 
-.single-content .poetry .poetry-line {
+.single-content .verse .verse-line {
   display: inline-block;
-  margin-inline-start: var(--poetry-indent, 0em);
+  margin-inline-start: var(--verse-indent, 0em);
   white-space: pre-wrap;
 }
 
-.single-content .poetry .poetry-line.i1 { --poetry-indent: 1.25em; }
-.single-content .poetry .poetry-line.i2 { --poetry-indent: 2.5em; }
-.single-content .poetry .poetry-line.i3 { --poetry-indent: 3.75em; }
-.single-content .poetry .poetry-line.i4 { --poetry-indent: 5em; }
-.single-content .poetry .poetry-line.i5 { --poetry-indent: 6.25em; }
-.single-content .poetry .poetry-line.i6 { --poetry-indent: 7.5em; }
-.single-content .poetry .poetry-line.i7 { --poetry-indent: 8.75em; }
-.single-content .poetry .poetry-line.i8 { --poetry-indent: 10em; }
+.single-content .verse .verse-line.i1 { --verse-indent: 1.25em; }
+.single-content .verse .verse-line.i2 { --verse-indent: 2.5em; }
+.single-content .verse .verse-line.i3 { --verse-indent: 3.75em; }
+.single-content .verse .verse-line.i4 { --verse-indent: 5em; }
+.single-content .verse .verse-line.i5 { --verse-indent: 6.25em; }
+.single-content .verse .verse-line.i6 { --verse-indent: 7.5em; }
+.single-content .verse .verse-line.i7 { --verse-indent: 8.75em; }
+.single-content .verse .verse-line.i8 { --verse-indent: 10em; }
+
+/* Numbered verse carries its numbers in a margin. A verse in columns is one
+   grid per verse line: its number, then each column's parts stacked, the
+   first in the normal tone and the rest muted, every part in the body serif
+   unless its face sets it. A narrow verse stacks the columns of each line. */
+.single-content .verse.verse-numbered {
+  position: relative;
+  padding-inline-start: 3em;
+}
+
+.single-content .verse .verse-number {
+  color: var(--text-muted);
+  font-size: 0.8em;
+}
+
+.single-content .verse-numbered .verse-line .verse-number {
+  position: absolute;
+  inset-inline-start: 0;
+  width: 2.2em;
+  text-align: end;
+}
+
+.single-content .verse.verse-columns {
+  container-type: inline-size;
+}
+
+.single-content .verse-numbered.verse-columns {
+  padding-inline-start: 0;
+}
+
+.single-content .verse-columns .verse-row {
+  display: grid;
+  grid-auto-flow: column;
+  grid-auto-columns: 1fr;
+  column-gap: 1.5rem;
+  margin-bottom: 0.5em;
+}
+
+.single-content .verse-numbered.verse-columns .verse-row {
+  grid-template-columns: 2.5em;
+}
+
+.single-content .verse-columns .verse-number {
+  text-align: end;
+  padding-top: 0.2em;
+}
+
+.single-content .verse-columns :is(.verse-column, .verse-part) {
+  display: block;
+  white-space: pre-wrap;
+}
+
+.single-content .verse-columns .verse-part {
+  font-family: var(--font-body);
+}
+
+.single-content .verse-columns .verse-secondary {
+  color: var(--text-muted);
+}
+
+.single-content .verse-columns .verse-part[dir="rtl"] {
+  text-align: start;
+}
+
+@container (max-width: 32rem) {
+  .single-content .verse-columns .verse-row {
+    grid-auto-flow: row;
+    grid-template-columns: 1fr;
+  }
+  .single-content .verse-numbered.verse-columns .verse-row {
+    grid-template-columns: 2.5em 1fr;
+  }
+  .single-content .verse-numbered.verse-columns .verse-column {
+    grid-column: 2;
+  }
+}
 
 /* Ornamental horizontal rule: thin line flanking a centered gold
    diamond. Uses gradients on ::before/::after to keep the markup
@@ -3021,6 +3097,8 @@ summary.info-sidebar-title::after {
 .single-body .dictionary > div > dd { display:inline; margin:0; font-weight:normal; }
 .single-body .dictionary > div > dd > :is(p, ul, ol, dl, blockquote, pre, table, div) { text-indent:0; }
 .single-body .dictionary > div > dd > p:first-child { display:inline; }
+.single-body .dictionary > div > dd + dd { display:block; text-indent:0; }
+.single-body .dictionary > div > dd + dd > p:first-child { display:block; }
 @media (max-width:600px) { .single-body .dictionary { --indent:100px; } }
 
 /* ---- Text in one of the faces ----
@@ -3028,7 +3106,7 @@ summary.info-sidebar-title::after {
    right-to-left block or verse reads from the right. `font=serif`, `sans`
    and `mono` set the site's own serif and mono, and the reader's sans. */
 .script-block { margin:1rem 0; line-height:1.7; }
-.script-block[dir="rtl"], .poetry[dir="rtl"] { text-align:start; }
+.script-block[dir="rtl"], .verse[dir="rtl"] { text-align:start; }
 .font-serif { font-family:var(--font-body); }
 .font-sans { font-family:sans-serif; }
 .font-mono { font-family:var(--font-mono); }