@heroiclands/package-build 25.5.1 → 25.5.3

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @heroiclands/package-build
 
+## 25.5.3
+
+**Verse**
+
+- Every `--- {.canto}` break draws a short centred rule on the site, in Foundry journals and in the book, whether or not it carries a title.
+- Decoded verse ends each canto mark with a line break, so the decoded text can be encoded again without the next word running into the mark.
+- Metre checks count only the verse itself, skipping speaker labels and stage directions.
+- Metre checks read a word's inherited word class, and accept every beat count a word with several senses can take.
+- A stanza ending in a footnote reference keeps its stanza mark in the native script, and the reference stays on the roman reading.
+- A line holding only spaces ends a verse stanza, just as an empty line does.
+
+## 25.5.2
+
+**Languages and scripts**
+
+- A sentence that runs across several spans and links in one language is checked as one sentence, so the period that ends it is not reported as opening the next.
+
 ## 25.5.1
 
 **Builds and commands**

package/assets/styles/content-base.css

@@ -239,7 +239,9 @@
     .verse
     .verse-canto-break {
     display: block;
-    height: 0.5em;
+    width: 25%;
+    margin: 1.5em auto;
+    border-block-start: 1px solid currentColor;
 }
 :is(.journal-entry-page, .journal-entry-content, .editor-content, .prosemirror)
     .verse-paired

package/docs/api.md

@@ -1449,12 +1449,14 @@ The charset authored content is held to, so a book can choose its face. The pack
 Exact permitted Roman source characters for configured languages, before script
 encoding. Inventories come from `data.roman` on each language's own note.
 
-| Export                   | Signature                                | Returns                       | Use it when                                                                                   |
-| ------------------------ | ---------------------------------------- | ----------------------------- | --------------------------------------------------------------------------------------------- |
-| `isRomanWhitespace`      | `isRomanWhitespace(char)`                | `boolean`                     | recognizing standard spaces and ASCII tab or line whitespace                                  |
-| `romanInventoryProblems` | `romanInventoryProblems(value)`          | `string[]`                    | checking NFC, repeated characters and forbidden whitespace or controls in a literal inventory |
-| `romanInventoriesOf`     | `romanInventoriesOf(records, languages)` | `Map<string, RomanInventory>` | looking up a configured language's own inventory by name or BCP 47 tag                        |
-| `romanTextProblems`      | `romanTextProblems(text, inventory)`     | `{offset, message}[]`         | validating standard Roman punctuation and language additions with exact UTF-16 offsets        |
+| Export                    | Signature                                    | Returns                       | Use it when                                                                                                                                                          |
+| ------------------------- | -------------------------------------------- | ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `isRomanWhitespace`       | `isRomanWhitespace(char)`                    | `boolean`                     | recognizing standard spaces and ASCII tab or line whitespace                                                                                                         |
+| `romanInventoryProblems`  | `romanInventoryProblems(value)`              | `string[]`                    | checking NFC, repeated characters and forbidden whitespace or controls in a literal inventory                                                                        |
+| `romanInventoriesOf`      | `romanInventoriesOf(records, languages)`     | `Map<string, RomanInventory>` | looking up a configured language's own inventory by name or BCP 47 tag                                                                                               |
+| `romanTextProblems`       | `romanTextProblems(text, inventory, stream)` | `{offset, message}[]`         | validating standard Roman punctuation and language additions with exact UTF-16 offsets; pass a `stream` state to continue sentences and quotations from earlier runs |
+| `romanPunctuationState`   | `romanPunctuationState()`                    | `{sentenceStart, quotes}`     | starting a stream of runs whose sentences and quotations continue from one run to the next                                                                           |
+| `romanUnclosedQuotations` | `romanUnclosedQuotations(quotes)`            | `{offset, message}[]`         | reporting the quotations still open where a stream of runs ends                                                                                                      |
 
 ### `engine.pathCharset`
 

package/docs/authoring/links-and-markup.md

@@ -411,7 +411,7 @@ Foundry renders a secret section; the website renders an expandable spoiler, and
 
 A `.verse` div sets a version of a work, whether poetry or prose. `/` ends a
 logical line. Source newlines otherwise join with whitespace, so prose can wrap
-across source lines. A blank line or `//` ends a stanza (a paragraph); a line
+across source lines. A blank line, including one containing only spaces, or `//` ends a stanza (a paragraph); a line
 of `--- {.canto}`, preceded by a blank line, ends a canto (a section). The last line before either
 boundary needs no `/`. A literal slash in text is written `\/`; slashes inside
 Markdown syntax, such as a link destination, remain syntax.
@@ -488,6 +488,9 @@ language's stress rules; it reports an error at the line:
 
 > `` `scan=` counts one language’s beats; this verse line contains another language ``
 
+Speaker labels and stage directions (`.speaker` and `.direction`) are presentation
+only: their text is not scanned, and a line containing only those spans is skipped.
+
 Beats are counted this way:
 
 - **Syllables** are vowel groups. A vowel is a letter whose base is `a`, `e`,
@@ -500,8 +503,10 @@ Beats are counted this way:
 - **A one-syllable noun, verb, adjective, numeral or name has a beat.** A
   one-syllable particle, preposition, conjunction, adverb or pronoun has none.
   The `class` of the lexicon entry decides, so the language's lexicon is read
-  through `lang=` as it is for the word check, and a form the language's rules
-  derive takes its word's class. A word whose entries differ in class is a
+  through `lang=` as it is for the word check, including words inherited from
+  its family. All entries for a spelling in the nearest lexicon supply their
+  classes. A form the
+  language's own rules derive takes its word's class. A word whose entries differ in class is a
   beat that may be left out.
 - **A one-syllable word the lexicon does not hold is a content word** and has a
   beat. The word check reports the word separately.
@@ -649,6 +654,8 @@ definitions.
 #### Canto headings
 
 A canto break stands alone after a blank line, with a stanza on both sides.
+It draws a short centred rule on the site, in Foundry journals and in the book,
+with extra space above and below to distinguish it from a stanza break.
 Its optional `title` appears as a heading and its optional `#id` is an anchor
 within the work, without starting a separate Foundry journal page:
 

package/docs/guides/writing-in-invented-scripts.md

@@ -542,8 +542,11 @@ The title is shown once as heading text; the encoder receives its Roman `***`
 canto control. Authored `***` inside verse is a finding. The canto stays within
 the work and does not open a separate journal page.
 
-The blank line before a canto retains its stanza mark in the encoded text.
-Whitespace after the canto control adds no extra line mark.
+The blank line before a canto retains its stanza mark in the encoded text,
+including when the last word has a footnote reference.
+Whitespace after the canto control adds no extra line mark. Decoding writes
+`***` followed by an LF newline, so the next word starts on a new line and
+the decoded Roman text can be encoded again.
 
 ### Versions of a work
 

package/docs/reference/theme-pages.md

@@ -336,7 +336,7 @@ Caption classes are unrestricted. The built-in `border` class draws the block as
 A `.verse` div reaches the page as `.verse`, with one `.verse-stanza` per
 stanza and `.verse-line` per logical line. Indentation uses `i1` through `i8`;
 deeper levels carry their complete `--verse-indent`. `.verse-canto-break`
-separates cantos. A work-labelled div adds `.verse-labelled`, and each stanza
+draws a short centred rule between cantos. A work-labelled div adds `.verse-labelled`, and each stanza
 opens with a small `.verse-label` shared across its presentations.
 
 A concrete div encoding adds `.verse-paired`. Each `.verse-row` aligns one

package/engine/content-scripts.mjs

@@ -63,7 +63,12 @@ import { unknownWordMessage, unknownWords, wordBooksFromRecords } from "./run-wo
 import { metreBooksFromRecords, metreFindings, metresFromRecords } from "./verse-metre.mjs";
 import { encodeWithLanguage } from "./encoding-language.mjs";
 import { encodingsFromRecords, encodingAddress } from "./encoding-notes.mjs";
-import { romanInventoriesOf, romanTextProblems } from "./roman-characters.mjs";
+import {
+    romanInventoriesOf,
+    romanPunctuationState,
+    romanTextProblems,
+    romanUnclosedQuotations,
+} from "./roman-characters.mjs";
 import { plainRomanRun } from "./roman-run.mjs";
 import { plainRomanVerse } from "./roman-verse.mjs";
 import { encodeText } from "./encoding.mjs";
@@ -1175,6 +1180,7 @@ function analyseRuns(source, ctx, syntax) {
             rawReferences.push({
                 lang: keys.lang,
                 font: keys.font,
+                enc: keys.enc,
                 from: match.index + 2 + bar + 1,
                 to: match.index + close - 1,
                 where: construct.where,
@@ -1363,24 +1369,6 @@ function analyseRuns(source, ctx, syntax) {
             (ctx.romanInventories?.get(lang) ?? ctx.romanInventories?.get(lang.toLowerCase()))
         );
 
-    /** Check visible source before selection or lexicon-native replacement. */
-    const roman = (parts, detail) => {
-        const inventory = inventoryOf(detail.run.lang);
-        if (!inventory) return;
-        if (!inventory.characters) {
-            report(
-                { line: detail.run.line, column: detail.run.column },
-                `the language note for \`${inventory.language}\` must declare \`data.roman\``,
-            );
-            return;
-        }
-        for (const [from, to] of parts) {
-            const plain = plainRomanRun(text, { from, to });
-            for (const problem of romanTextProblems(plain.text, inventory))
-                report(positionOf(starts, plain.offsets[problem.offset] ?? from), problem.message);
-        }
-    };
-
     /**
      * Give a scroll fence the face it is set in, and report a fence that names
      * none or whose script is written in lines. A fence that names no face
@@ -1646,7 +1634,128 @@ function analyseRuns(source, ctx, syntax) {
             .filter((detail) => detail.run.kind === "span")
             .map((detail) => [detail.run.start, detail]),
     );
-    for (const owner of details.filter((detail) => ownerOf(detail) === detail)) {
+    // Inline runs, spans and labelled links, of one resolved language and
+    // encoding separated only by whitespace form one punctuation stream: a
+    // sentence or a quotation may run through several of them. Each run opens
+    // in the state its predecessor in the stream closed in, and quotations
+    // still open are reported once, where the stream ends. A block (a div,
+    // verse or scroll) is a stream of its own and never joins an inline run,
+    // as a paragraph does not continue a sentence from outside it; it still
+    // separates the runs on either side of it.
+    const ownerDetails = details
+        .filter((detail) => ownerOf(detail) === detail)
+        .sort((a, b) => a.run.start - b.run.start);
+    const streamEntry = (where, lang, enc, checkable, inline) => {
+        const inventory = inventoryOf(lang);
+        // A block's bounds are its opening and closing line indices.
+        const end = Math.min(where.end, lines.length - 1);
+        return {
+            inline,
+            start: inline ? where.start : starts[where.start],
+            end: inline ? where.end : starts[end] + lines[end].length,
+            line: where.line,
+            column: where.column,
+            lang,
+            language: tagOf(lang)?.toLowerCase() ?? lang,
+            enc,
+            inventory,
+            checked: checkable && Boolean(inventory?.characters),
+            previous: undefined,
+            continued: false,
+            state: undefined,
+            problems: undefined,
+        };
+    };
+    const streamRuns = [
+        ...ownerDetails.map((detail) => ({
+            ...streamEntry(
+                detail.run,
+                detail.run.lang,
+                detail.run.enc,
+                Boolean(boundsOf(detail) && detail.checkRoman),
+                detail.run.kind === "span",
+            ),
+            detail,
+        })),
+        ...rawReferences.map((reference) => ({
+            ...streamEntry(reference.where, reference.lang, reference.enc, true, true),
+            reference,
+        })),
+    ].sort((a, b) => a.start - b.start);
+    for (const entry of streamRuns) {
+        if (!entry.checked || !entry.inline) continue;
+        const previous = streamRuns
+            .filter((other) => other.end <= entry.start)
+            .reduce((last, other) => (last && last.end >= other.end ? last : other), undefined);
+        if (
+            previous?.checked &&
+            previous.inline &&
+            previous.inventory === entry.inventory &&
+            previous.language === entry.language &&
+            previous.enc === entry.enc &&
+            /^[\p{Zs}\t\r\n]*$/u.test(text.slice(previous.end, entry.start))
+        ) {
+            entry.previous = previous;
+            previous.continued = true;
+        }
+    }
+    const streamRunOf = new Map(
+        streamRuns.filter((entry) => entry.detail).map((entry) => [entry.detail, entry]),
+    );
+    /** The punctuation state a run opens in, a copy of its predecessor's. */
+    const openingState = (entry) => {
+        const previous = entry.previous && closingState(entry.previous);
+        return previous ?
+                {
+                    sentenceStart: previous.sentenceStart,
+                    quotes: previous.quotes.map((quote) => ({ ...quote })),
+                }
+            :   romanPunctuationState();
+    };
+    /** A run's closing punctuation state, checking a labelled link on demand. */
+    const closingState = (entry) => {
+        if (entry.reference) checkReference(entry);
+        return entry.state;
+    };
+    /**
+     * Check a run's Roman text in its stream, giving findings by source offset.
+     *
+     * @param {any} entry - The run.
+     * @param {string} roman - Its projected Roman text.
+     * @param {(offset: number) => number} source - A text offset's source offset.
+     */
+    const checkStream = (entry, roman, source) => {
+        const state = openingState(entry);
+        const problems = romanTextProblems(roman, entry.inventory, state).map((problem) => ({
+            ...problem,
+            offset: source(problem.offset),
+        }));
+        for (const quote of state.quotes) quote.source ??= source(quote.offset);
+        if (!entry.continued)
+            problems.push(
+                ...romanUnclosedQuotations(
+                    state.quotes.map((quote) => ({ ...quote, offset: quote.source })),
+                ),
+            );
+        entry.state = state;
+        return problems;
+    };
+    /** Check a labelled link's Roman source once, in its stream. */
+    const checkReference = (entry) => {
+        if (entry.problems) return entry.problems;
+        entry.problems = [];
+        if (!entry.checked) return entry.problems;
+        const { reference } = entry;
+        const plain = plainRomanRun(text, { from: reference.from, to: reference.to });
+        entry.problems = checkStream(
+            entry,
+            plain.text,
+            (offset) => plain.offsets[offset] ?? reference.from,
+        );
+        return entry.problems;
+    };
+
+    for (const owner of ownerDetails) {
         const bounds = boundsOf(owner);
         if (!bounds || !owner.checkRoman) continue;
         const owned = details.filter((detail) => ownerOf(detail) === owner);
@@ -1703,12 +1812,15 @@ function analyseRuns(source, ctx, syntax) {
                 { line: owner.run.line, column: owner.run.column },
                 `the language note for \`${inventory.language}\` must declare \`data.roman\``,
             );
-        else if (inventory)
-            for (const problem of romanTextProblems(projection.text, inventory))
-                report(
-                    positionOf(starts, projection.offsets[problem.offset] ?? bounds[0]),
-                    problem.message,
-                );
+        else if (inventory) {
+            const entry = streamRunOf.get(owner);
+            for (const problem of checkStream(
+                entry,
+                projection.text,
+                (offset) => projection.offsets[offset] ?? bounds[0],
+            ))
+                report(positionOf(starts, problem.offset), problem.message);
+        }
         for (const problem of projection.errors ?? [])
             report(positionOf(starts, problem.offset), problem.message);
 
@@ -1830,16 +1942,15 @@ function analyseRuns(source, ctx, syntax) {
         for (const detail of owned) detail.plan = plan;
     }
 
-    for (const reference of rawReferences) {
-        const font = reference.font;
-        roman([[reference.from, reference.to]], {
-            run: {
-                lang: reference.lang,
-
-                ...reference.where,
-            },
-            face: font === undefined ? undefined : faces.get(font),
-        });
+    for (const entry of streamRuns.filter((entry) => entry.reference)) {
+        const inventory = inventoryOf(entry.lang);
+        if (inventory && !inventory.characters)
+            report(
+                { line: entry.line, column: entry.column },
+                `the language note for \`${inventory.language}\` must declare \`data.roman\``,
+            );
+        for (const problem of checkReference(entry))
+            report(positionOf(starts, problem.offset), problem.message);
     }
 
     for (const reference of independentReferences) {
@@ -2484,7 +2595,13 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
                 });
                 if (positions.length)
                     patches.push({ from: positions[0], to: positions.at(-1) + 1, text: edit.text });
-                else if (edit.from === edit.to && edit.from === base + line.to)
+                else if (
+                    (edit.from === edit.to && edit.from === base + line.to) ||
+                    (edit.from > base + (line.offsets.at(-1) ?? line.from) &&
+                        edit.to <= base + line.to)
+                )
+                    // Trailing source whitespace has no logical-text offsets.
+                    // It may still carry a stanza control after a footnote hole.
                     patches.push({ from: line.text.length, to: line.text.length, text: edit.text });
             }
             let result = line.text;

package/engine/content-verse.mjs

@@ -569,7 +569,8 @@ export function parseVerse(body, { inline = false, footnotes = new Set() } = {})
             const length = source[at] === "\r" && source[at + 1] === "\n" ? 2 : 1;
             if (text && !/\s$/.test(text)) append(" ", at);
             at += length;
-            while (source[at] === " ") at++;
+            // Leave blank physical lines at their start so they end the stanza.
+            if (!/^[ \t]*(?:\r\n|\r|\n|$)/.test(source.slice(at))) while (source[at] === " ") at++;
             continue;
         }
         if (!text && source[at] === " ") {

package/engine/encoding-lexicon.mjs

@@ -229,8 +229,9 @@ function languageNotes(languages, contentPackage, records) {
 
 /**
  * Each configured language's lexicon, read from the language note its `note`
- * names and its family chain. The nearest exact NFC form supplies the whole
- * word; grammar, registers and other settings remain the daughter's own.
+ * names and its family chain. All entries for an exact NFC form come from
+ * the nearest lexicon declaring it; 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.
@@ -259,8 +260,10 @@ export function lexiconsFromRecords(records, config = {}) {
         const chain = lineageChain(key, lineage);
         let data = resolvedNativeData(record.data, record.package ?? config.contentPackage);
         if (chain.length > 1) {
-            const words = new Map();
-            for (const ancestor of chain)
+            const words = [];
+            const inherited = new Set();
+            for (const ancestor of chain) {
+                const forms = new Set();
                 for (const word of listOf(
                     resolvedNativeData(
                         byKey.get(ancestor).data,
@@ -268,12 +271,15 @@ export function lexiconsFromRecords(records, config = {}) {
                     )?.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);
+                    // Retain every sense in the nearest generation, in authored
+                    // order, before hiding that form in more distant ancestors.
+                    if (!inherited.has(form)) words.push(word);
+                    forms.add(form);
                 }
-            data = { ...data, words: [...words.values()] };
+                for (const form of forms) inherited.add(form);
+            }
+            data = { ...data, words };
         }
         lexicons.set(name, lexiconOf(name, data));
     }

package/engine/encoding.mjs

@@ -256,7 +256,7 @@ export function compileRows(definition, metadata = {}) {
     const prefix = d.separator ? [separatorRow] : [];
     const controlRows = [];
     if (controls.verseStanza) controlRows.push({ from: "\n\n", to: controls.verseStanza });
-    if (controls.verseCanto) controlRows.push({ from: "***", to: controls.verseCanto });
+    if (controls.verseCanto) controlRows.push({ from: "***\n", to: controls.verseCanto });
     const shared = tier(sharedRows, [], [...prefix, ...controlRows]);
     const faces = new Map();
     if (d.faces !== undefined && !object(d.faces))

package/engine/pdf-render.mjs

@@ -1297,7 +1297,9 @@ function workVerse(token, poem, ctx) {
                         `#heading(level: 3, outlined: false, bookmarked: false)[${renderInline({ children: group.titleChildren }, ctx)}]`
                     :   "";
                 const anchor = group.id ? ` <${sectionLabel(ctx.anchorPrefix, group.id)}>` : "";
-                return `${mark ? scriptWrapped(mark, nativeClasses, nativeAttributes) + "\n" : ""}#v(0.5em)${heading ? "\n" + heading : ""}${anchor}`;
+                const rule =
+                    "#v(0.75em)\n#align(center)[#line(length: 25%, stroke: 0.4pt)]\n#v(0.75em)";
+                return `${mark ? scriptWrapped(mark, nativeClasses, nativeAttributes) + "\n" : ""}${rule}${heading ? "\n" + heading : ""}${anchor}`;
             }
             const label = labelled ? `#text(size: 0.75em, fill: luma(45%))[${group.label}]` : "";
             const lineText = (line, roman = false) => {

package/engine/roman-characters.mjs

@@ -109,9 +109,14 @@ export function romanInventoriesOf(records, languages = {}) {
  * No punctuation, case or normalization repair is performed.
  * @param {string} text - Visible Roman source.
  * @param {RomanInventory} inventory - Its language's declared characters.
+ * @param {RomanPunctuationState} [stream] - The punctuation state of a stream
+ *   of runs the text continues, from {@link romanPunctuationState}; updated to
+ *   the state the text closes in. Its unclosed quotations are left for
+ *   {@link romanUnclosedQuotations} at the end of the stream. Without it the
+ *   text is a stream of its own and its unclosed quotations are reported.
  * @returns {Array<{offset: number, message: string}>}
  */
-export function romanTextProblems(text, inventory) {
+export function romanTextProblems(text, inventory, stream) {
     const out = [];
     if (!inventory.characters) return out;
     const decomposed = new Map(
@@ -119,8 +124,9 @@ export function romanTextProblems(text, inventory) {
             .filter(({ segment }) => segment !== segment.normalize("NFC"))
             .map(({ segment, index }) => [index, segment]),
     );
-    const quotes = [];
-    let sentenceStart = true;
+    const state = stream ?? romanPunctuationState();
+    const { quotes } = state;
+    let sentenceStart = state.sentenceStart;
     const sentenceText = () => {
         sentenceStart = false;
         if (quotes.length) quotes.at(-1).hasText = true;
@@ -245,10 +251,41 @@ export function romanTextProblems(text, inventory) {
         } else sentenceText();
         offset += char.length;
     }
-    for (const opening of quotes)
-        report(
-            opening.offset,
-            `quotation \`${opening.char}\` needs its closing \`${opening.char === "«" ? "»" : "›"}\``,
-        );
+    state.sentenceStart = sentenceStart;
+    if (!stream) out.push(...romanUnclosedQuotations(quotes));
     return out.sort((a, b) => a.offset - b.offset);
 }
+
+/**
+ * @typedef {object} RomanQuotation
+ * @property {string} char - The opening mark, `«` or `‹`.
+ * @property {number} offset - Its offset in the text that opened it.
+ * @property {boolean} sentenceStart - Whether its sentence had text before it.
+ * @property {boolean} hasText - Whether it holds sentence text.
+ */
+
+/**
+ * @typedef {object} RomanPunctuationState
+ * @property {boolean} sentenceStart - Whether no sentence text precedes the next mark.
+ * @property {RomanQuotation[]} quotes - Open quotations, outermost first.
+ */
+
+/**
+ * The punctuation state at the start of a stream of runs.
+ * @returns {RomanPunctuationState}
+ */
+export function romanPunctuationState() {
+    return { sentenceStart: true, quotes: [] };
+}
+
+/**
+ * Findings for quotations still open at the end of a stream.
+ * @param {ReadonlyArray<RomanQuotation>} quotes - The open quotations.
+ * @returns {Array<{offset: number, message: string}>} At each opening's `offset`.
+ */
+export function romanUnclosedQuotations(quotes) {
+    return quotes.map((opening) => ({
+        offset: opening.offset,
+        message: `quotation \`${opening.char}\` needs its closing \`${opening.char === "«" ? "»" : "›"}\``,
+    }));
+}

package/engine/verse-metre.mjs

@@ -52,7 +52,7 @@
 import { nearest } from "./near-miss.mjs";
 import { isNoteRecord } from "./index-records.mjs";
 import { METRE_KINDS, METRE_NAME } from "./metre-declaration.mjs";
-import { languageRecordsByName } from "./encoding-lexicon.mjs";
+import { lexiconsFromRecords } from "./encoding-lexicon.mjs";
 import { STRESS_LONGER, STRESS_MARKS, STRESS_TWO } from "./language-terms.mjs";
 import { parseWordClass } from "./word-classes.mjs";
 import { derivedForms, foldWord } from "./word-forms.mjs";
@@ -169,8 +169,8 @@ const isRule = (stress) =>
  */
 export function metreBooksFromRecords(records, config = {}) {
     const books = new Map();
-    for (const [language, record] of languageRecordsByName([...(records ?? [])], config)) {
-        const data = isMap(record.data) ? record.data : {};
+    for (const [language, lexicon] of lexiconsFromRecords(records, config)) {
+        const data = lexicon.data;
         const sounds = isMap(data.sounds) ? data.sounds : {};
         if (!isRule(sounds.stress)) continue;
         const syllables = isMap(sounds.syllables) ? sounds.syllables : {};
@@ -358,9 +358,29 @@ export function metreFindings(blocks, lines, ctx) {
                         ({ offset }) =>
                             !model.layout.some(([from, to]) => offset >= from && offset < to),
                     );
-                const tokens =
+                const parsed =
                     verseParser.parseInline(units.map((unit) => unit.text).join(""), {})[0]
                         ?.children ?? [];
+                let presentationDepth = 0;
+                const tokens = parsed.filter((token) => {
+                    if (presentationDepth) {
+                        presentationDepth += token.nesting;
+                        return false;
+                    }
+                    if (
+                        token.type === "span_open" &&
+                        token
+                            .attrGet("class")
+                            ?.split(/\s+/)
+                            .some((name) => name === "speaker" || name === "direction")
+                    ) {
+                        presentationDepth = 1;
+                        return false;
+                    }
+                    return true;
+                });
+                const text = inlineText(tokens);
+                if (!text.trim()) continue;
                 const tag = (name) => (ctx.languages?.[name]?.tag ?? name).toLowerCase();
                 const foreign = tokens.find(
                     (token) =>
@@ -375,7 +395,7 @@ export function metreFindings(blocks, lines, ctx) {
                     );
                     continue;
                 }
-                const beats = lineBeats(inlineText(tokens), book);
+                const beats = lineBeats(text, book);
                 if (metre.beats >= beats.min && metre.beats <= beats.max) continue;
                 warnings.push({
                     ...sourcePosition(reading.from),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "25.5.1",
+    "version": "25.5.3",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package \u2014 content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",

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

@@ -1444,7 +1444,9 @@ a.tag:hover {
 .single-content .verse .verse-line.i8 { --verse-indent: 10em; }
 .single-content .verse .verse-canto-break {
     display: block;
-    height: 0.5em;
+    width: 25%;
+    margin: 1.5em auto;
+    border-block-start: 1px solid currentColor;
 }
 .single-content .verse-paired .verse-row {
     display: grid;

package/types/engine/encoding-lexicon.d.mts

@@ -1,7 +1,8 @@
 /**
  * Each configured language's lexicon, read from the language note its `note`
- * names and its family chain. The nearest exact NFC form supplies the whole
- * word; grammar, registers and other settings remain the daughter's own.
+ * names and its family chain. All entries for an exact NFC form come from
+ * the nearest lexicon declaring it; 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.

package/types/engine/roman-characters.d.mts

@@ -26,9 +26,40 @@ export function romanInventoriesOf(records: ReadonlyMap<string, Record<string, a
  * No punctuation, case or normalization repair is performed.
  * @param {string} text - Visible Roman source.
  * @param {RomanInventory} inventory - Its language's declared characters.
+ * @param {RomanPunctuationState} [stream] - The punctuation state of a stream
+ *   of runs the text continues, from {@link romanPunctuationState}; updated to
+ *   the state the text closes in. Its unclosed quotations are left for
+ *   {@link romanUnclosedQuotations} at the end of the stream. Without it the
+ *   text is a stream of its own and its unclosed quotations are reported.
  * @returns {Array<{offset: number, message: string}>}
  */
-export function romanTextProblems(text: string, inventory: RomanInventory): Array<{
+export function romanTextProblems(text: string, inventory: RomanInventory, stream?: RomanPunctuationState): Array<{
+    offset: number;
+    message: string;
+}>;
+/**
+ * @typedef {object} RomanQuotation
+ * @property {string} char - The opening mark, `«` or `‹`.
+ * @property {number} offset - Its offset in the text that opened it.
+ * @property {boolean} sentenceStart - Whether its sentence had text before it.
+ * @property {boolean} hasText - Whether it holds sentence text.
+ */
+/**
+ * @typedef {object} RomanPunctuationState
+ * @property {boolean} sentenceStart - Whether no sentence text precedes the next mark.
+ * @property {RomanQuotation[]} quotes - Open quotations, outermost first.
+ */
+/**
+ * The punctuation state at the start of a stream of runs.
+ * @returns {RomanPunctuationState}
+ */
+export function romanPunctuationState(): RomanPunctuationState;
+/**
+ * Findings for quotations still open at the end of a stream.
+ * @param {ReadonlyArray<RomanQuotation>} quotes - The open quotations.
+ * @returns {Array<{offset: number, message: string}>} At each opening's `offset`.
+ */
+export function romanUnclosedQuotations(quotes: ReadonlyArray<RomanQuotation>): Array<{
     offset: number;
     message: string;
 }>;
@@ -43,3 +74,31 @@ export type RomanInventory = {
      */
     characters: ReadonlySet<string> | undefined;
 };
+export type RomanQuotation = {
+    /**
+     * - The opening mark, `«` or `‹`.
+     */
+    char: string;
+    /**
+     * - Its offset in the text that opened it.
+     */
+    offset: number;
+    /**
+     * - Whether its sentence had text before it.
+     */
+    sentenceStart: boolean;
+    /**
+     * - Whether it holds sentence text.
+     */
+    hasText: boolean;
+};
+export type RomanPunctuationState = {
+    /**
+     * - Whether no sentence text precedes the next mark.
+     */
+    sentenceStart: boolean;
+    /**
+     * - Open quotations, outermost first.
+     */
+    quotes: RomanQuotation[];
+};