@heroiclands/package-build 24.0.4 → 24.1.1

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/script-font-delivery.mjs

@@ -76,14 +76,15 @@ const FRONTMATTER = /^\uFEFF?---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
  *
  * @param {string} source - The note's file.
  * @param {import("./script-fonts.mjs").ScriptFonts} installed - The fonts package.
+ * @param {import("./content-session.mjs").ContentNoteSource} [parsed] - Already parsed authored note.
  * @returns {string|undefined} The face's slug.
  */
-function writtenInFace(source, installed) {
+function writtenInFace(source, installed, parsed) {
     const yaml = FRONTMATTER.exec(source)?.[1];
     if (yaml === undefined) return undefined;
     let fm;
     try {
-        fm = YAML.parse(yaml);
+        fm = parsed ? parsed.frontmatter : YAML.parse(yaml);
     } catch {
         return undefined;
     }
@@ -102,10 +103,12 @@ function writtenInFace(source, installed) {
  *
  * @param {DeliveryConfig} config - The resolved configuration.
  * @param {import("./script-fonts.mjs").ScriptFonts} installed - The fonts package.
+ * @param {import("./content-session.mjs").ContentSession} [session] - Captured sources when staging within a content build.
  * @returns {ReadonlySet<string>} The slugs of the faces used.
  */
-export function facesUsed(config, installed) {
-    const known = usedFaces.get(config);
+export function facesUsed(config, installed, session) {
+    const cacheKey = session ?? config;
+    const known = usedFaces.get(cacheKey);
     if (known) return known;
     const used = new Set();
     const content =
@@ -119,9 +122,9 @@ export function facesUsed(config, installed) {
             const full = path.join(dir, entry.name);
             if (entry.isDirectory()) walk(full);
             else if (entry.isFile() && entry.name.endsWith(".md")) {
-                const source = fs.readFileSync(full, "utf8");
+                const source = session?.sources.get(full)?.raw ?? fs.readFileSync(full, "utf8");
                 if (/^\s*writtenIn:/m.test(source)) {
-                    const face = writtenInFace(source, installed);
+                    const face = writtenInFace(source, installed, session?.parsed.get(full));
                     if (face) used.add(face);
                 }
                 if (!/\bfont=/.test(source)) continue;
@@ -135,7 +138,7 @@ export function facesUsed(config, installed) {
         }
     };
     if (content && fs.existsSync(content)) walk(content);
-    usedFaces.set(config, used);
+    usedFaces.set(cacheKey, used);
     return used;
 }
 
@@ -143,15 +146,16 @@ export function facesUsed(config, installed) {
  * The installed package, when this consumer is to ship it.
  *
  * @param {DeliveryConfig} config - The resolved configuration.
+ * @param {import("./content-session.mjs").ContentSession} [session] - Captured sources.
  * @returns {import("./script-fonts.mjs").ScriptFonts|undefined} The package, or
  *   `undefined` without a root, an install, a manifest, or a note that sets
  *   text in one of its faces.
  */
-function delivered(config) {
+function delivered(config, session) {
     if (!config?.rootDir) return undefined;
     const installed = resolveScriptFonts(config.rootDir);
     if (!installed?.manifest) return undefined;
-    return facesUsed(config, installed).size ? installed : undefined;
+    return facesUsed(config, installed, session).size ? installed : undefined;
 }
 
 /**
@@ -159,12 +163,13 @@ function delivered(config) {
  *
  * @param {DeliveryConfig} config - The resolved configuration.
  * @param {string[]} formats - The font formats the target uses: `woff2`, `ttf`.
+ * @param {import("./content-session.mjs").ContentSession} [session] - Captured sources when staging within a content build.
  * @returns {{root: string, version: string, files: string[]}|undefined} The
  *   files, sorted: `fonts.css`, `LICENSE` and every file in `fonts/` of a
  *   listed format. `undefined` when the consumer ships none.
  */
-export function scriptFontFiles(config, formats) {
-    const installed = delivered(config);
+export function scriptFontFiles(config, formats, session) {
+    const installed = delivered(config, session);
     if (!installed) return undefined;
     const fontsDir = path.join(installed.root, "fonts");
     const fonts =
@@ -250,10 +255,11 @@ export function stagedStylesheet(css, staged) {
  * @param {string} dest - The directory to fill; created when there is
  *   something to put in it.
  * @param {string[]} formats - The font formats the target uses.
+ * @param {import("./content-session.mjs").ContentSession} [session] - Captured sources when staging within a content build.
  * @returns {number} How many files were written; 0 when the consumer ships none.
  */
-export function copyScriptFonts(config, dest, formats) {
-    const found = scriptFontFiles(config, formats);
+export function copyScriptFonts(config, dest, formats, session) {
+    const found = scriptFontFiles(config, formats, session);
     if (!found) return 0;
     const staged = new Set(found.files);
     for (const file of found.files) {
@@ -274,11 +280,12 @@ export function copyScriptFonts(config, dest, formats) {
  * stylesheet, the licence and every file the manifest lists.
  *
  * @param {DeliveryConfig} config - The resolved configuration.
+ * @param {import("./content-session.mjs").ContentSession} [session] - Captured sources when staging within a content build.
  * @returns {{file: string, severity: "error", message: string}[]} One finding
  *   per missing file, located at the manifest; empty when the consumer ships none.
  */
-export function checkScriptFonts(config) {
-    const installed = delivered(config);
+export function checkScriptFonts(config, session) {
+    const installed = delivered(config, session);
     if (!installed) return [];
     const manifest = path.join(installed.root, FONTS_MANIFEST);
     const wanted = new Set([STYLESHEET, LICENSE]);

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.4",
+    "version": "24.1.1",
     "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;
 }

package/types/engine/build-assets.d.mts

@@ -0,0 +1,23 @@
+/**
+ * The repository's `packageBuild.assetTransform`, loaded.
+ *
+ * One loader for every command that writes a picture, so the stage and the CDN
+ * hold the same bytes for the same file.
+ *
+ * @param {object} config - The resolved package-build configuration.
+ * @returns {Promise<((sourcePath: string) => string|null|undefined)|undefined>}
+ *   The transform, or `undefined` when the repository names none.
+ */
+export function loadAssetTransform(config: object): Promise<((sourcePath: string) => string | null | undefined) | undefined>;
+/**
+ * Stage static files, provenance-filtered pictures, base styles and fonts.
+ * @param {object} [options]
+ * @param {ReturnType<typeof loadPackageBuildConfig>} [options.config]
+ * @param {import("../content-config.mjs").ContentBuildConfig} [options.packConfig]
+ * @param {import("./content-session.mjs").ContentSession} [options.session]
+ */
+export function stagePackageBuildAssets({ config, packConfig, session, }?: {
+    config?: Readonly<import("../config.mjs").PackageBuildConfig> | undefined;
+    packConfig?: import("../content-config.mjs").ContentBuildConfig | undefined;
+    session?: import("./content-session.mjs").ContentSession | undefined;
+}): Promise<void>;

package/types/engine/calendar-artifacts.d.mts

@@ -3,11 +3,15 @@
  *
  * @param {object} opts
  * @param {object} opts.config - Resolved content configuration.
+ * @param {Map<string, {raw: string}>} [opts.sources] - Captured authored text for diagnostics.
  * @param {string} opts.calendariaVersion - Version whose import format is targeted.
  * @returns {{directory: string, calendars: number, files: number}}
  */
-export function emitCalendarArtifacts({ config, calendariaVersion }?: {
+export function emitCalendarArtifacts({ config, calendariaVersion, sources }?: {
     config: object;
+    sources?: Map<string, {
+        raw: string;
+    }> | undefined;
     calendariaVersion: string;
 }): {
     directory: string;