@heroiclands/package-build 24.0.3 → 24.1.0

package/engine/core-report.mjs

@@ -18,7 +18,8 @@
  * The list is the `data.concepts` of the package's `doc` notes. A language
  * must cover it where it states `data.core: true`. A word covers every
  * concept its `concept` names, and a language reads the words of its
- * `data.family` chain as its own. A missing concept is a fact to work through,
+ * `data.family` chain as its own, with the nearest definition of each form
+ * winning. A missing concept is a fact to work through,
  * never a finding.
  *
  * @module
@@ -114,9 +115,16 @@ export function coreReport(records, { language } = {}) {
         concepts: concepts.length,
         languages: chosen.map((record) => {
             const have = new Set();
+            const forms = new Set();
             for (const key of chain(noteAddressOf(record) ?? ""))
-                for (const word of byKey.get(key)?.data?.words ?? [])
+                for (const word of byKey.get(key)?.data?.words ?? []) {
+                    if (!isMap(word) || typeof word.form !== "string") continue;
+                    // Match dictionary headwords: NFC, retaining case and word separators.
+                    const form = word.form.normalize("NFC");
+                    if (forms.has(form)) continue;
+                    forms.add(form);
                     for (const id of idsOf(word)) have.add(id);
+                }
             const missing = [];
             for (const group of groups) {
                 const members = concepts.filter((concept) => concept.group === group);

package/engine/map-lexicon.mjs

@@ -59,7 +59,7 @@ import { fromWrittenIn } from "./written-in.mjs";
 import { writingsOf } from "./logographic.mjs";
 import { FONTS_PACKAGE } from "./script-fonts.mjs";
 import { GENERIC_FAMILIES, applyMap } from "./text-maps.mjs";
-import { isLanguageRecord, noteAddressOf } from "./word-rows.mjs";
+import { isLanguageRecord, lineageChain, noteAddressOf } from "./word-rows.mjs";
 import { derivedForms } from "./word-forms.mjs";
 import { LANGUAGE_SUBTYPE, glossText } from "./word-terms.mjs";
 
@@ -183,7 +183,7 @@ function lexiconOf(language, data) {
  * @returns {string|undefined} The Address.
  */
 function noteKey(note, contentPackage, types) {
-    if (typeof note !== "string" || !contentPackage) return undefined;
+    if (!contentPackage) return undefined;
     const tuple = parseAddress(
         note,
         { package: contentPackage, system: "note", type: "skill", types: new Set(types) },
@@ -248,7 +248,9 @@ function languageNotes(languages, contentPackage, records) {
 
 /**
  * Each configured language's lexicon, read from the language note its `note`
- * names. A language with no `note`, or one naming no language note, has none.
+ * names and its family chain. The nearest exact NFC form supplies the whole
+ * word; grammar, registers and other settings remain the daughter's own.
+ * A language with no `note`, or one naming no language note, has none.
  *
  * @param {Iterable<Record<string, any>>|undefined} records - Index records.
  * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
@@ -256,9 +258,39 @@ function languageNotes(languages, contentPackage, records) {
  * @returns {Map<string, Lexicon>} The lexicons by language name.
  */
 export function lexiconsFromRecords(records, config = {}) {
+    const list = [...(records ?? [])];
+    const byKey = recordsByKey(list, config.contentPackage);
+    const types = new Set(["skill", ...list.map((record) => record?.type).filter(Boolean)]);
+    const lineage = {
+        has: (key) => isLanguage(byKey.get(key)),
+        parentOf: (key) => {
+            const record = byKey.get(key);
+            return noteKey(record.data?.family, record.package ?? config.contentPackage, types);
+        },
+    };
     const lexicons = new Map();
-    for (const [name, record] of languageRecordsByName(records, config))
-        lexicons.set(name, lexiconOf(name, record.data));
+    for (const [name, { key, record }] of languageNotes(
+        config.languages,
+        config.contentPackage,
+        list,
+    )) {
+        if (!record) continue;
+        const chain = lineageChain(key, lineage);
+        let data = record.data;
+        if (chain.length > 1) {
+            const words = new Map();
+            for (const ancestor of chain)
+                for (const word of listOf(byKey.get(ancestor).data?.words)) {
+                    if (!isMap(word) || typeof word.form !== "string") continue;
+                    // The nearest complete definition wins before word matching
+                    // folds case or splits compounds. Only words are inherited.
+                    const form = word.form.normalize("NFC");
+                    if (!words.has(form)) words.set(form, word);
+                }
+            data = { ...data, words: [...words.values()] };
+        }
+        lexicons.set(name, lexiconOf(name, data));
+    }
     return lexicons;
 }
 

package/engine/note-vocabulary.mjs

@@ -2209,9 +2209,9 @@ export const NOTE_VOCABULARY = Object.freeze({
                     },
                 ]),
                 describe:
-                    "The script the language is written in, as the map and the face a run marked " +
-                    "with its name alone takes; a run's own `map=` or `font=` overrides it. Only a " +
-                    "skill of `subType: language` states it.",
+                    "The script the language is written in, as the default map and face selected " +
+                    "by a run with explicit `lang=` and `.nativefont`; a run's own `map=` or " +
+                    "`font=` overrides its half. Only a skill of `subType: language` states it.",
             },
             {
                 name: "script",
@@ -2451,8 +2451,8 @@ export const NOTE_VOCABULARY = Object.freeze({
                     },
                 ]),
                 describe:
-                    "A mapping, which text marked `map=` with its `name` is rewritten by " +
-                    "before it is set. See " +
+                    "A mapping, which native text marked with `lang=`, `.nativefont` and its " +
+                    "`map=` name is rewritten by before it is set. See " +
                     "[mapping notes](format-details.md#mapping-notes).",
             },
             {

package/engine/pdf-render.mjs

@@ -87,13 +87,11 @@ import { GENERIC_FONTS, renderRuns, scanRuns } from "./content-scripts.mjs";
 import { scanFigures } from "./content-figures.mjs";
 import { BLOCK_CONTAINERS, scanBlocks, BLOCK_NAMES } from "./content-blocks.mjs";
 import {
-    COLUMNS_CLASS,
-    STANZA_BREAK,
+    hasColumns,
     lineNumber,
     rightToLeft,
     scanVerse,
-    verseColumns,
-    verseStanzas,
+    verseColumnCount,
 } from "./content-verse.mjs";
 import { matchAllOutsideCode, replaceOutsideCode } from "./code-fences.mjs";
 import { panelRoman, scanScrolls, scrollPanels, scrollParagraphs } from "./content-scroll.mjs";
@@ -763,20 +761,28 @@ function renderBlock(tokens, i, out, ctx) {
             }
             if (token.type === "fence" && /^verse(?:\s|$)/.test(token.info?.trim() || "")) {
                 const opening = `${token.markup}${token.info}`;
-                const poem = scanVerse(`${opening}\n${token.content}${token.markup}`).blocks[0];
+                const scanned = scanVerse(`${opening}\n${token.content}${token.markup}`);
+                // Findings are collected before rendering. Keep malformed verse
+                // literal rather than assigning invalid parts to display cells.
+                if (scanned.errors.length) {
+                    out.push(rawBlock(token.content, token.info));
+                    return 1;
+                }
+                const poem = scanned.blocks[0];
                 const step = Number(poem?.attributes.numstep ?? 0) || 0;
                 const content =
-                    poem?.classes.includes(COLUMNS_CLASS) ?
-                        verseGrid(token, poem, opening, step, ctx)
+                    hasColumns(poem) ? verseGrid(token, poem, step, ctx)
                     : step ? numberedVerse(token, step, ctx)
                     : token.meta.verseStanzas
                             .map((stanza) =>
-                                stanza
-                                    .map(({ children, level }) => {
-                                        const verse = renderInline({ children }, ctx);
-                                        return `${level ? `#h(${level * 1.25}em)` : ""}${verse}`;
-                                    })
-                                    .join(" \\\n"),
+                                stanza[0]?.stanzaBreak ?
+                                    "#v(0.5em)"
+                                :   stanza
+                                        .map(({ children, level }) => {
+                                            const verse = renderInline({ children }, ctx);
+                                            return `${level ? `#h(${level * 1.25}em)` : ""}${verse}`;
+                                        })
+                                        .join(" \\\n"),
                             )
                             .join("\n\n");
                 const anchor = poem?.id ? ` <${sectionLabel(ctx.anchorPrefix, poem.id)}>` : "";
@@ -1291,12 +1297,14 @@ const typstNumber = (number) => (number ? `[#text(fill: luma(45%))[${number}]]`
 function numberedVerse(token, step, ctx) {
     let count = 0;
     const stanzas = token.meta.verseStanzas.map((stanza) =>
-        stanza
-            .map(({ children, level }) => {
-                const verse = renderInline({ children }, ctx);
-                return `  ${typstNumber(lineNumber(++count, step))}, [${level ? `#h(${level * 1.25}em)` : ""}${verse}],`;
-            })
-            .join("\n"),
+        stanza[0]?.stanzaBreak ?
+            "  grid.cell(colspan: 2)[#v(0.5em)],"
+        :   stanza
+                .map(({ children, level }) => {
+                    const verse = renderInline({ children }, ctx);
+                    return `  ${typstNumber(lineNumber(++count, step))}, [${level ? `#h(${level * 1.25}em)` : ""}${verse}],`;
+                })
+                .join("\n"),
     );
     return [
         "#grid(columns: (2.5em, 1fr), column-gutter: 1em, row-gutter: 0.35em,",
@@ -1309,44 +1317,52 @@ function numberedVerse(token, step, ctx) {
  * A verse in columns: a grid with a row per verse line, its number first when
  * the verse is numbered, then each column's entries stacked, the first in the
  * normal tone and each later one grey. A part whose text runs right to left
- * is set right to left inside its cell, and the grid keeps the page's
- * direction, so the columns stay in order. A `***` line is a row of space
+ * is set right to left inside its cell; the grid stays left to right so
+ * numbered columns retain their authored order. A `***` line is a row of space
  * across the grid.
  *
- * @param {object} token - The expanded verse's fence token.
+ * @param {object} token - The verse's fence token with parsed logical rows.
  * @param {object} poem - The verse, from `scanVerse`.
- * @param {string} opening - Its opening line.
  * @param {number} step - Its `numstep`.
  * @param {object} ctx - Render context.
  * @returns {string} Typst markup.
  */
-function verseGrid(token, poem, opening, step, ctx) {
-    const counts = verseColumns(poem, opening).map((column) => column.entries.length);
-    const width = counts.length + (step ? 1 : 0);
-    const columns = [...(step ? ["2.5em"] : []), ...counts.map(() => "1fr")];
-    const raw = verseStanzas(token.content);
+function verseGrid(token, poem, step, ctx) {
+    const count = verseColumnCount(poem);
+    const width = count + (step ? 1 : 0);
+    const columns = [...(step ? ["2.5em"] : []), ...Array(count).fill("1fr")];
     const rows = [];
-    let count = 0;
-    token.meta.verseStanzas.forEach((group, at) => {
-        if (raw[at].length === 1 && STANZA_BREAK.test(raw[at][0].text)) {
+    let row = 0;
+    for (const group of token.meta.verseGroups) {
+        if (group.stanzaBreak) {
             rows.push(`  grid.cell(colspan: ${width})[#v(0.5em)],`);
-            return;
+            continue;
         }
-        const parts = group.map(({ children }, k) => {
-            const part = renderInline({ children }, ctx);
-            return rightToLeft(raw[at][k].text) ? `#set text(dir: rtl)\n${part}` : part;
-        });
-        let next = 0;
-        const cells = counts.map((n) => {
-            const stacked = parts.slice(next, (next += n));
+        const cells = Array.from({ length: count }, () => []);
+        for (const part of group.parts) {
+            const rtl = rightToLeft(part.text);
+            const secondary = cells[part.column - 1].length > 0;
+            const text = renderInline(
+                { children: part.children },
+                secondary ? { ...ctx, textFill: "luma(45%)" } : ctx,
+            );
+            const padded =
+                part.indent ?
+                    `#pad(${rtl ? "right" : "left"}: ${part.indent * 1.25}em)[${text}]`
+                :   text;
+            cells[part.column - 1].push(rtl ? `#set text(dir: rtl)\n${padded}` : padded);
+        }
+        const rendered = cells.map((stacked) => {
+            if (!stacked.length) return "[]";
             if (stacked.length === 1) return `[${stacked[0]}]`;
             return `[#stack(dir: ttb, spacing: 0.3em, ${stacked.map((part, k) => (k ? `[#text(fill: luma(45%))[${part}]]` : `[${part}]`)).join(", ")})]`;
         });
-        const number = step ? [typstNumber(lineNumber(++count, step))] : [];
-        rows.push(`  ${[...number, ...cells].join(", ")},`);
-    });
+        const number = step ? [typstNumber(lineNumber(++row, step))] : [];
+        rows.push(`  ${[...number, ...rendered].join(", ")},`);
+    }
     return [
-        `#grid(columns: (${columns.join(", ")}${columns.length === 1 ? "," : ""}), column-gutter: 1.5em, row-gutter: 0.65em,`,
+        "#set text(dir: ltr)",
+        `#grid(columns: (${columns.join(", ")}), column-gutter: 1.5em, row-gutter: 0.65em,`,
         ...rows,
         ")",
     ].join("\n");
@@ -1440,7 +1456,7 @@ function renderInline(token, ctx) {
             case "script_emphasis_open":
                 out.push(
                     child.meta?.convention === "rubric" ?
-                        "#text(fill: book-rubric)["
+                        `#text(fill: ${ctx.textFill ?? "book-rubric"})[`
                     :   "#overline[",
                 );
                 break;
@@ -1675,6 +1691,9 @@ function pageOfLabel(label) {
  * @returns {string} Typst markup.
  */
 function renderLink(href, inner, ctx, { bracketed = false } = {}) {
+    // A secondary verse reading keeps its label gray inside the global blue
+    // link presentation, including any native spans or emphasis in that label.
+    if (ctx.textFill) inner = `#text(fill: ${ctx.textFill})[${inner}]`;
     const url = String(href ?? "");
     const fragment = /#([^?]*)/.exec(url)?.[1] ?? "";
     if (url.startsWith("#") && fragment)

package/engine/run-rows.mjs

@@ -17,9 +17,10 @@
  * column value and none is a key, so two notes writing one tag in different
  * case are two rows. Documentation records and assets contribute no rows.
  *
- * A run's `font` and `map` are the ones it is set with: its own, else those of
- * the div or fence around it, else those its language's note names in
- * `data.writtenIn`, filled by {@link fillWrittenIn} once every record exists.
+ * Native runs retain their explicit opt-in so language defaults can be filled
+ * by {@link fillWrittenIn} once every record exists. Roman language-only runs
+ * retain null map/font fields; ordinary generic-family inheritance is already
+ * projected by the shared scanner.
  *
  * @module
  */
@@ -30,7 +31,7 @@ import { isNoteRecord } from "./index-records.mjs";
 import { scanRuns } from "./content-scripts.mjs";
 import { languageRecordsByName } from "./map-lexicon.mjs";
 import { mapsFromRecords } from "./text-maps.mjs";
-import { fromWrittenIn, writtenInOf } from "./written-in.mjs";
+import { writtenInOf } from "./written-in.mjs";
 
 /** Every column of the `runs` relation, in order. */
 export const RUN_COLUMNS = Object.freeze([
@@ -52,10 +53,12 @@ export const RUN_COLUMNS = Object.freeze([
  * @property {string|null} lang - The language it is set in, as written: its
  *   own `lang=`, else the one the div or fence around it states.
  * @property {string|null} tag - The BCP 47 tag it resolves to, or null.
- * @property {string|null} font - Its font, as written and inherited the same
- *   way, else its language's script's.
- * @property {string|null} map - Its map, as written and inherited the same way,
- *   else its language's script's.
+ * @property {string|null} font - Its explicit font, an inherited ordinary
+ *   prose family, or the configured default for an opted-in native run.
+ * @property {string|null} map - Its explicit map or the configured map of an
+ *   opted-in native run; null for Roman language-only text.
+ * @property {boolean} [nativefont] - Explicit native opt-in on this construct;
+ *   absent on Roman runs. This internal flag is not a SQL column.
  * @property {number} line - 1-based file line of its opening.
  * @property {number} column - 1-based UTF-16 file column of its opening.
  */
@@ -84,13 +87,14 @@ export function recordRuns(body, { context, bodyLine = 1, bodyColumn = 1, syntax
         tag: run.tag ?? null,
         font: run.font ?? null,
         map: run.map ?? null,
+        ...(run.nativefont ? { nativefont: true } : {}),
         line: bodyLine + run.line - 1,
         column: run.column + (run.line === 1 ? bodyColumn - 1 : 0),
     }));
 }
 
 /**
- * Give every recorded run the map and face its language's note names in
+ * Give explicitly native recorded runs the map and face their language names in
  * `data.writtenIn`, where the run leaves them unstated, as a run is set. Read
  * once every record exists, since a run's language note may be recorded after
  * the note that marks it.
@@ -107,17 +111,11 @@ export function fillWrittenIn(records, config) {
     for (const record of records) {
         if (!record || !isNoteRecord(record) || !Array.isArray(record.runs)) continue;
         for (const run of record.runs) {
-            const filled = fromWrittenIn(
-                {
-                    lang: run.lang ?? undefined,
-                    map: run.map ?? undefined,
-                    font: run.font ?? undefined,
-                },
-                scripts,
-                maps,
-            );
-            if (filled.map !== undefined) run.map = filled.map;
-            if (filled.font !== undefined) run.font = filled.font;
+            if (!run.nativefont) continue;
+            const script = scripts.get(run.lang);
+            if (!script) continue;
+            if (run.map == null) run.map = script.map;
+            if (run.font == null) run.font = script.font;
         }
     }
 }

package/engine/run-words.mjs

@@ -36,7 +36,7 @@
  * @module
  */
 
-import { languageRecordsByName } from "./map-lexicon.mjs";
+import { lexiconsFromRecords } from "./map-lexicon.mjs";
 import { RESERVED_TONGUE } from "./language-terms.mjs";
 import { addWords, foldWord, lexiconWords } from "./word-forms.mjs";
 import { WORD } from "./word-pattern.mjs";
@@ -82,7 +82,8 @@ export function registeredNameWords(data) {
 
 /**
  * Each configured language's word book: one per language whose `note` names a
- * language note.
+ * language note. Its effective lexicon shares the renderer's nearest inherited
+ * words, and derives forms and registered names from its own settings.
  *
  * @param {Iterable<Record<string, any>>|undefined} records - Index records.
  * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
@@ -92,11 +93,10 @@ export function registeredNameWords(data) {
 export function wordBooksFromRecords(records, config = {}) {
     const list = [...(records ?? [])];
     const books = new Map();
-    const languages = languageRecordsByName(list, config);
-    if (!languages.size) return books;
-    for (const [name, record] of languages) {
-        const own = lexiconWords(record.data);
-        const names = registeredNameWords(record.data);
+    const lexicons = lexiconsFromRecords(list, config);
+    for (const [name, lexicon] of lexicons) {
+        const own = lexiconWords(lexicon.data);
+        const names = registeredNameWords(lexicon.data);
         books.set(
             name,
             Object.freeze({

package/engine/verse-metre.mjs

@@ -58,6 +58,13 @@ import { parseWordClass } from "./word-classes.mjs";
 import { derivedForms, foldWord } from "./word-forms.mjs";
 import { WORD } from "./word-pattern.mjs";
 
+import MarkdownIt from "markdown-it";
+import { spanMarkdownPlugin } from "./content-spans.mjs";
+import { STANZA_BREAK, verseLine } from "./content-verse.mjs";
+import { inlineText } from "./name-markup.mjs";
+
+const verseParser = new MarkdownIt().use(spanMarkdownPlugin);
+
 export { METRE_KINDS, METRE_NAME, checkMetresField } from "./metre-declaration.mjs";
 
 /** The bases whose one-syllable words carry a beat. */
@@ -285,7 +292,7 @@ export function metreMessage({ min, max }, metre) {
  * @param {ReadonlyArray<{start: number, end: number, indent: string, attributes: Record<string, string>, classes: string[]}>} blocks -
  *   The fences, from {@link module:engine/content-verse.scanVerse}.
  * @param {string[]} lines - The source's lines.
- * @param {{metres?: ReadonlyMap<string, import("./metre-declaration.mjs").Metre>, metreBooks?: ReadonlyMap<string, MetreBook>, lexicons?: ReadonlyMap<string, unknown>, columnsClass: string, columnKeys: readonly string[], attributeColumns: (line: string, key: string) => {key: number, value: number}}} ctx -
+ * @param {{languages?: Readonly<Record<string, {tag: string}>>, metres?: ReadonlyMap<string, import("./metre-declaration.mjs").Metre>, metreBooks?: ReadonlyMap<string, MetreBook>, lexicons?: ReadonlyMap<string, unknown>, attributeColumns: (line: string, key: string) => {key: number, value: number}}} ctx -
  *   The metres and books, and how the fence says its columns and where its
  *   keys sit.
  * @returns {{errors: object[], warnings: object[]}} The findings at 1-based
@@ -304,13 +311,10 @@ export function metreFindings(blocks, lines, ctx) {
             column: ctx.attributeColumns(opening, key)[part],
         });
         const error = (position, message) => errors.push({ ...position, message });
-        if (
-            block.classes.includes(ctx.columnsClass) ||
-            ctx.columnKeys.some((key) => block.attributes[key] !== undefined)
-        ) {
+        if (Number(block.attributes.cols ?? 1) > 1) {
             error(
                 at("scan", "key"),
-                "`scan=` counts the beats of one language's lines; a verse in columns sets a line in each of two",
+                "`scan=` counts the beats of one language's lines; a verse with cols>1 groups independent physical lines",
             );
             continue;
         }
@@ -344,8 +348,32 @@ export function metreFindings(blocks, lines, ctx) {
         }
         for (let line = block.start + 1; line < block.end; line++) {
             const text = lines[line];
-            if (!text.trim()) continue;
-            const beats = lineBeats(text, book);
+            if (!text.trim() || STANZA_BREAK.test(text.trim())) continue;
+            const reading = verseLine(text);
+            const tokens = verseParser.parseInline(reading.text, {})[0]?.children ?? [];
+            const tag = (name) => (ctx.languages?.[name]?.tag ?? name).toLowerCase();
+            const foreign = tokens.find(
+                (token) =>
+                    token.type === "span_open" &&
+                    token.attrGet("lang") &&
+                    tag(token.attrGet("lang")) !== tag(lang),
+            );
+            if (foreign) {
+                error(
+                    {
+                        line: line + 1,
+                        column:
+                            reading.textColumn +
+                            foreign.meta.start +
+                            (reading.markerStart <= reading.textColumn - 1 + foreign.meta.start ?
+                                reading.markerLength
+                            :   0),
+                    },
+                    "`scan=` counts one language's beats; this verse line contains another language",
+                );
+                continue;
+            }
+            const beats = lineBeats(inlineText(tokens), book);
             if (metre.beats >= beats.min && metre.beats <= beats.max) continue;
             warnings.push({
                 line: line + 1,

package/engine/written-in.mjs

@@ -20,20 +20,16 @@
  *   writtenIn: { map: semaron, font: semaron-kuriale }
  * ```
  *
- * A run marked with the language's name takes them where it states neither:
- * `[Zaron tholmeza]{lang=vyl}` is mapped by `semaron` and set in
- * `semaron-kuriale`. A run that states one of the two takes the other from the
- * default only where they agree, so the run is never set in a face its map is
- * not drawn in:
+ * These are native-presentation defaults, not an effect of identifying a
+ * language. A rendering run requests them with its own `.nativefont` class
+ * and explicit `lang=`; plain `[Zaron tholmeza]{lang=vyl}` stays Roman.
+ * The renderer fills the map and font independently, honoring explicit
+ * overrides and reporting an incompatible pair rather than silently omitting
+ * a default. A nested marked run makes its own presentation choice.
  *
- * - **`map=` alone** takes the default `font` where that map is drawn in it.
- * - **`font=` alone** takes the default `map` where the map is drawn in that
- *   face.
- * - **Both** take nothing.
- *
- * The default belongs to the run's own language, after a div or fence around
- * it has given it its keys: a span marked `lang=en` inside a div of a language
- * with a default takes no face from it.
+ * The low-level `fromWrittenIn` helper also serves explicit conversion
+ * commands. It returns compatible default suggestions to those callers;
+ * rendering opt-in and its required-font diagnostics belong to the run reader.
  *
  * @module
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "24.0.3",
+    "version": "24.1.0",
     "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/site-theme/static/css/style.css

@@ -1384,7 +1384,7 @@ a.tag:hover {
   background: var(--bg-card);
 }
 
-/* Verse lines are hard breaks in the markup; paragraphs mark stanzas. */
+/* Verse groups are paragraphs; explicit stanza separators add their own gap. */
 .single-content .verse {
   margin: 1.5rem 0;
   line-height: 1.7;
@@ -1404,14 +1404,16 @@ a.tag:hover {
   white-space: pre-wrap;
 }
 
-.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; }
+.single-content .verse :is(.verse-line, .verse-part).i1 { --verse-indent: 1.25em; }
+.single-content .verse :is(.verse-line, .verse-part).i2 { --verse-indent: 2.5em; }
+.single-content .verse :is(.verse-line, .verse-part).i3 { --verse-indent: 3.75em; }
+.single-content .verse :is(.verse-line, .verse-part).i4 { --verse-indent: 5em; }
+.single-content .verse :is(.verse-line, .verse-part).i5 { --verse-indent: 6.25em; }
+.single-content .verse :is(.verse-line, .verse-part).i6 { --verse-indent: 7.5em; }
+.single-content .verse :is(.verse-line, .verse-part).i7 { --verse-indent: 8.75em; }
+.single-content .verse :is(.verse-line, .verse-part).i8 { --verse-indent: 10em; }
+
+.single-content .verse .verse-stanza-break { display: block; height: 0.5em; }
 
 /* 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
@@ -1446,12 +1448,14 @@ a.tag:hover {
   display: grid;
   grid-auto-flow: column;
   grid-auto-columns: 1fr;
+  direction: ltr;
+  grid-template-columns: repeat(var(--verse-columns, 2), minmax(0, 1fr));
   column-gap: 1.5rem;
   margin-bottom: 0.5em;
 }
 
 .single-content .verse-numbered.verse-columns .verse-row {
-  grid-template-columns: 2.5em;
+  grid-template-columns: 2.5em repeat(var(--verse-columns, 2), minmax(0, 1fr));
 }
 
 .single-content .verse-columns .verse-number {
@@ -1466,12 +1470,17 @@ a.tag:hover {
 
 .single-content .verse-columns .verse-part {
   font-family: var(--font-body);
+  padding-inline-start: var(--verse-indent, 0em);
 }
 
 .single-content .verse-columns .verse-secondary {
   color: var(--text-muted);
 }
 
+.single-content .verse-columns .verse-secondary * {
+  color: inherit;
+}
+
 .single-content .verse-columns .verse-part[dir="rtl"] {
   text-align: start;
 }