@heroiclands/package-build 25.3.0 → 25.4.0

package/engine/first-use.mjs

@@ -45,6 +45,7 @@ import remarkFrontmatter from "remark-frontmatter";
 import remarkGfm from "remark-gfm";
 import MarkdownIt from "markdown-it";
 import { readQualifier } from "./address.mjs";
+import { verseRegions } from "./verse-regions.mjs";
 import { scanBlocks } from "./content-blocks.mjs";
 import { scanFigures } from "./content-figures.mjs";
 import { RUN_KEYS } from "./content-scripts.mjs";
@@ -169,14 +170,37 @@ const overlaps = (values, value) => {
  * Explicit inline occurrences, authored strong text and structural exclusions
  * at original source offsets.
  */
-function prose(source, capturedNames) {
+function prose(source, capturedNames, capturedSpans) {
     const links = [],
         paragraphs = [],
         regions = [],
         excluded = [],
         strong = [],
         html = [];
-    const masked = source
+    const spans = capturedSpans ?? scanSpans(source);
+    const verseMasks = verseRegions(source).map((region) => ({
+        start: region.from,
+        end: region.to,
+        block: true,
+    }));
+    for (const span of spans.spans)
+        if (
+            span.verseModel ||
+            span.attrs.some(
+                ([key, value]) => key === "class" && value.split(/\s+/).includes("verse"),
+            )
+        )
+            verseMasks.push({ start: span.start, end: span.end, block: false });
+    excluded.push(...verseMasks);
+    const verseRanges = verseMasks
+        .sort((a, b) => a.start - b.start || b.end - a.end)
+        .filter(
+            (range, index, all) =>
+                !all
+                    .slice(0, index)
+                    .some((parent) => parent.start <= range.start && parent.end >= range.end),
+        );
+    let masked = source
         .replace(/!\[\[[^\]\n]+\]\]|\{\{[^}\n]+\}\}/g, (text, start) => {
             excluded.push({ start, end: start + text.length });
             return blank(text);
@@ -193,6 +217,11 @@ function prose(source, capturedNames) {
             });
             return "x".repeat(text.length);
         });
+    for (const range of [...verseRanges].reverse())
+        masked =
+            masked.slice(0, range.start) +
+            masked.slice(range.start, range.end).replace(/[^\r\n]/g, range.block ? " " : "x") +
+            masked.slice(range.end);
     const tree = parser.parse(masked);
     const env = { references: Object.create(null) };
     const inline = (node) => {
@@ -285,7 +314,7 @@ function prose(source, capturedNames) {
     });
     const authoredLinks = [...new Map(actualLinks.map((link) => [link.start, link])).values()];
     const linked = ranges(authoredLinks);
-    const marked = (capturedNames ?? scanSpans(source).names)
+    const marked = (capturedNames ?? spans.names)
         .filter((span) => eligible(span) && !contains(linked, span))
         .map((span) => ({
             ...span,
@@ -373,7 +402,7 @@ export function nameUses(markdown, vocabulary) {
     // Every use carries the class, so a body without it is read no further.
     if (!source.includes(".name")) return [];
     const spans = scanSpans(source);
-    const { marked, links, strong, inParagraph } = prose(source, spans.names);
+    const { marked, links, strong, inParagraph } = prose(source, spans.names, spans);
     const starts = [0];
     for (let i = 0; i < source.length; i++) if (source[i] === "\n") starts.push(i + 1);
     // A caption and a named block's opening and closing lines are not prose.
@@ -527,14 +556,16 @@ export function createFirstUseChecker({
     const { recognize } = catalog;
     return ({ file, raw }) => {
         const authored = parsed?.get(file);
-        const capturedNames =
-            authored?.raw === raw && Number.isInteger(authored.bodyLine) ?
-                rebaseNameSpans(
-                    (syntax ? syntax(authored.body).spans : scanSpans(authored.body)).names,
-                    { raw, bodyLine: authored.bodyLine, bodyColumn: authored.bodyColumn },
-                )
-            :   undefined;
-        const { marked } = prose(raw, capturedNames);
+        let captured;
+        if (authored?.raw === raw && Number.isInteger(authored.bodyLine)) {
+            const inventory = syntax ? syntax(authored.body).spans : scanSpans(authored.body);
+            const context = { raw, bodyLine: authored.bodyLine, bodyColumn: authored.bodyColumn };
+            captured = {
+                names: rebaseNameSpans(inventory.names, context),
+                spans: rebaseNameSpans(inventory.spans, context),
+            };
+        }
+        const { marked } = prose(raw, captured?.names, captured);
         const findings = new Map();
         const add = (offset, rule, message) => {
             if (!findings.has(offset)) findings.set(offset, { rules: [], messages: [] });

package/engine/heading-attributes.mjs

@@ -40,7 +40,8 @@ import { blockTokens } from "./markdown-blocks.mjs";
 function literalHeadingLines(source) {
     const lines = new Set();
     for (const token of blockTokens(source)) {
-        if (!token.map || !["fence", "code_block", "html_block"].includes(token.type)) continue;
+        if (!token.map || !["fence", "code_block", "html_block", "verse_div"].includes(token.type))
+            continue;
         for (let line = token.map[0]; line < token.map[1]; line++) lines.add(line);
     }
     return lines;

package/engine/journals.mjs

@@ -76,6 +76,7 @@ import { journalHasContent } from "./note-state.mjs";
 import { hasLexicalEntries } from "./lexical-sections.mjs";
 import { draftNoticeFor } from "./draft-notice.mjs";
 import { scanFigures } from "./content-figures.mjs";
+import { verseRegions } from "./verse-regions.mjs";
 import { separateFootnotes } from "./content-footnotes.mjs";
 import { WITHHELD_CLASS, pageOpenings } from "./heading-attributes.mjs";
 import { imagesIn } from "./content-images.mjs";
@@ -154,6 +155,12 @@ export function splitPages(body, leadName = "Introduction", resolveRole, syntax)
         scanFigures(markdown, { resolveRole }).figures.map((figure) => [figure.line - 1, figure]),
     );
     const blockLines = namedBlockLines(markdown, syntax);
+    const verseLines = new Set();
+    for (const region of verseRegions(markdown))
+        for (let line = region.start; line <= region.end; line++) {
+            blockLines.add(line);
+            verseLines.add(line);
+        }
     const openings = pageOpenings(markdown, blockLines);
     const pages = [];
     const beforeFirstH1 = [];
@@ -189,7 +196,7 @@ export function splitPages(body, leadName = "Introduction", resolveRole, syntax)
         // carry a shorter fence of its own as literal content, same as
         // {@link module:engine/content-blocks.scanBlocks} and
         // {@link module:engine/content-figures.scanFigures} track it.
-        const fence = /^ {0,3}(`{3,}|~{3,})/.exec(line);
+        const fence = verseLines.has(lineIndex) ? null : /^ {0,3}(`{3,}|~{3,})/.exec(line);
         if (codeFence) {
             if (fence && fence[1][0] === codeFence[0] && fence[1].length >= codeFence.length) {
                 codeFence = null;

package/engine/markdown-blocks.mjs

@@ -25,9 +25,10 @@
  */
 
 import MarkdownIt from "markdown-it";
+import { verseDivPlugin } from "./verse-regions.mjs";
 
 /** The renderer's block grammar, with inline parsing and its passes switched off. */
-const parser = new MarkdownIt({ html: true });
+const parser = new MarkdownIt({ html: true }).use(verseDivPlugin);
 parser.core.ruler.disable(["inline", "linkify", "replacements", "smartquotes", "text_join"]);
 
 /** How many recent sources keep their tokens. */
@@ -51,7 +52,7 @@ export function blockTokens(source) {
         recent.set(text, hit);
         return hit;
     }
-    const tokens = parser.parse(text, {});
+    const tokens = parser.parse(text, { verseSource: text });
     recent.set(text, tokens);
     if (recent.size > RECENT) recent.delete(recent.keys().next().value);
     return tokens;

package/engine/markup-validation.mjs

@@ -14,6 +14,8 @@
 import { scanBlocks } from "./content-blocks.mjs";
 import { scanAlerts } from "./content-alerts.mjs";
 import { scanRuns } from "./content-scripts.mjs";
+import { scanSpans } from "./content-spans.mjs";
+import { verseRegions } from "./verse-regions.mjs";
 import { matchAllOutsideCode } from "./code-fences.mjs";
 
 /** The opening of a shortcode: `{{<` or `{{%`. */
@@ -55,9 +57,24 @@ export function markupFindings(source, file, syntax, runs) {
     );
     const scanned = syntax?.(body);
     const marked = runs ? scanRuns(body, runs, syntax) : undefined;
+    const spans = scanned?.spans ?? scanSpans(body);
+    const verseRanges = [
+        ...verseRegions(body).map((region) => [region.from, region.to]),
+        ...spans.spans.filter((span) => span.verseModel).map((span) => [span.start, span.end]),
+    ];
+    const starts = [0];
+    for (const match of body.matchAll(/\n/g)) starts.push(match.index + 1);
+    const verseErrors = spans.errors.filter((error) => {
+        const offset = (starts[error.line - 1] ?? 0) + error.column - 1;
+        return (
+            error.message.includes(".verse") ||
+            verseRanges.some(([from, to]) => offset >= from && offset < to)
+        );
+    });
     const errors = [
         ...(scanned?.blocks ?? scanBlocks(body)).errors,
         ...(scanned?.alerts ?? scanAlerts(body)).errors,
+        ...verseErrors,
         ...(marked?.errors ?? []),
         ...shortcodeErrors(body),
     ].map((error) => ({

package/engine/name-markup.mjs

@@ -42,6 +42,7 @@
  * @property {string} visible - Visible text from the actual parsed children.
  * @property {ReadonlyArray<readonly [string, string]>} attrs - Retained permitted HTML attributes.
  * @property {Record<string, SpanAttributePosition>} attributePositions - Authored key/value sites by retained attribute name.
+ * @property {ReturnType<typeof import("./content-verse.mjs").parseVerse>} [verseModel] - Logical model of an inline verse quotation.
  */
 
 /**

package/engine/note-vocabulary.mjs

@@ -2338,7 +2338,7 @@ export const NOTE_VOCABULARY = Object.freeze({
                             ...TEXT,
                             required: true,
                             describe:
-                                "What a verse fence's `scan=` names the metre by: lowercase " +
+                                "What a verse div's `scan=` names the metre by: lowercase " +
                                 "letters, digits and `-`, unique in the package.",
                         },
                         {
@@ -2362,7 +2362,7 @@ export const NOTE_VOCABULARY = Object.freeze({
                     ]),
                 }),
                 describe:
-                    "The metres a verse fence's `scan=` names. A fence that states one is " +
+                    "The metres a verse div's `scan=` names. A div that states one is " +
                     "warned at each line that cannot have its beats. See " +
                     "[metres](../authoring/links-and-markup.md#metre).",
             },

package/engine/pdf-render.mjs

@@ -86,7 +86,7 @@ import { scanSpans } from "./content-spans.mjs";
 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 { rightToLeft, scanVerse } from "./content-verse.mjs";
+import { rightToLeft } from "./content-verse.mjs";
 import { matchAllOutsideCode, replaceOutsideCode } from "./code-fences.mjs";
 import { panelRoman, scanScrolls, scrollPanels, scrollParagraphs } from "./content-scroll.mjs";
 import { BOOK_INK, BOOK_RUBRIC, fontOutlines, scrollPanelSvg } from "./font-outlines.mjs";
@@ -499,7 +499,7 @@ export function markdownToTypst(markdown, opts = {}) {
     const given = opts.nested ? String(markdown ?? "") : stripHtmlComments(markdown);
     const separated = opts.footnoteDefinitions === undefined ? separateFootnotes(given) : null;
     const authored = separated?.markdown ?? given;
-    const definitions = opts.footnoteDefinitions ?? separated?.definitions ?? "";
+    let definitions = opts.footnoteDefinitions ?? separated?.definitions ?? "";
     const footnoteState = opts.footnoteState ?? { seen: new Set() };
     const sharedOptions = {
         ...opts,
@@ -513,10 +513,16 @@ export function markdownToTypst(markdown, opts = {}) {
     // Text marked with a language, a font or a map is rewritten once, ahead of
     // every other pass, line for line; the nested calls below read the result,
     // and the scroll fences' layouts the rewrite returns.
+    const markingSource = definitions ? `${authored}\n\n${definitions}` : authored;
     const marked =
-        opts.nested ? undefined : renderRuns(authored, opts.runs, undefined, { target: "book" });
-    const source = marked ? marked.markdown : authored;
+        opts.nested ? undefined : (
+            renderRuns(markingSource, opts.runs, undefined, { target: "book" })
+        );
+    const markedFootnotes = marked && definitions ? separateFootnotes(marked.markdown) : undefined;
+    const source = markedFootnotes?.markdown ?? marked?.markdown ?? authored;
+    if (markedFootnotes) definitions = markedFootnotes.definitions;
     if (marked) {
+        sharedOptions.footnoteDefinitions = definitions;
         sharedOptions.scrolls = marked.scrolls;
         sharedOptions.verses = marked.verses;
     }
@@ -775,22 +781,14 @@ function renderBlock(tokens, i, out, ctx) {
                 out.push(scrollBlock(token, ctx));
                 return 1;
             }
-            if (token.type === "fence" && /^verse(?:\s|$)/.test(token.info?.trim() || "")) {
-                const opening = `${token.markup}${token.info}`;
-                const scanned = scanVerse(`${opening}\n${token.content}${token.markup}`, {
-                    checkWorks: false,
-                });
-                // Findings are collected before rendering. Keep malformed verse
-                // literal rather than assigning invalid parts to display cells.
-                if (scanned.errors.length && !token.meta?.versePaired) {
-                    out.push(rawBlock(token.content, token.info));
-                    return 1;
-                }
-                const poem = scanned.blocks[0];
-                const content = workVerse(token, poem, ctx);
-                const anchor = poem?.id ? ` <${sectionLabel(ctx.anchorPrefix, poem.id)}>` : "";
-                out.push(`\n#block(width: 100%)[${content}]${anchor}\n`);
-            } else out.push(rawBlock(token.content, token.info?.trim() || ""));
+            out.push(rawBlock(token.content, token.info?.trim() || ""));
+            return 1;
+        }
+        case "verse_div": {
+            const poem = token.meta.verse;
+            const content = workVerse(token, poem, ctx);
+            const anchor = poem?.id ? ` <${sectionLabel(ctx.anchorPrefix, poem.id)}>` : "";
+            out.push(`\n#block(width: 100%)[${content}]${anchor}\n`);
             return 1;
         }
         case "hr":
@@ -1286,15 +1284,20 @@ const FONT_CLASSES = Object.freeze(["script", ...Object.values(GENERIC_FONTS)]);
 /** The logical lines of one stanza, with a shared label and paired scripts. */
 function workVerse(token, poem, ctx) {
     const paired = token.meta.versePaired;
-    const labelled = Boolean(poem?.attributes.work);
+    const labelled = token.type !== "verse_inline" && Boolean(poem?.attributes.work);
     const nativeClasses = paired?.classes ?? poem?.classes;
     const nativeAttributes = paired?.attributes ?? poem?.attributes;
-    return (token.meta.verseGroups ?? [])
+    const body = (token.meta.verseGroups ?? [])
         .map((group) => {
             if (group.cantoBreak) {
                 const mark =
                     group.children?.length ? renderInline({ children: group.children }, ctx) : "";
-                return `${mark ? scriptWrapped(mark, nativeClasses, nativeAttributes) + "\n" : ""}#v(0.5em)`;
+                const heading =
+                    group.titleChildren?.length ?
+                        `#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 label = labelled ? `#text(size: 0.75em, fill: luma(45%))[${group.label}]` : "";
             const lineText = (line, roman = false) => {
@@ -1328,6 +1331,8 @@ function workVerse(token, poem, ctx) {
             return `#set text(dir: ltr)\n#grid(columns: (${columns}), column-gutter: 1.5em, row-gutter: 0.35em,\n  ${cells.join(",\n  ")}\n)`;
         })
         .join("\n\n");
+    const notes = (token.meta.verseNotes ?? []).map((line) => renderInline(line, ctx)).join("");
+    return body + notes;
 }
 
 /**
@@ -1374,6 +1379,12 @@ function renderInline(token, ctx) {
             case "code_inline":
                 out.push(inlineRaw(child.content));
                 break;
+            case "verse_inline": {
+                const content = workVerse(child, child.meta.verse, ctx);
+                const id = child.attrGet?.("id");
+                out.push(`#box[${content}]${id ? ` <${sectionLabel(ctx.anchorPrefix, id)}>` : ""}`);
+                break;
+            }
             case "span_open": {
                 if (["em", "strong"].includes(child.tag)) {
                     const classes = (child.attrGet?.("class") ?? "").split(/\s+/);

package/engine/prose-lint.mjs

@@ -35,6 +35,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { formatNoteFrontmatter } from "./note-format.mjs";
+import { protectVerseSource } from "./verse-format.mjs";
 
 import {
     MARKDOWNLINT_CONFIG,
@@ -161,6 +162,17 @@ export async function checkFormatting(root, opts = {}) {
             }
         }
 
+        const format = async (input) => {
+            const protectedSource =
+                ["markdown", "mdx"].includes(info.inferredParser) ?
+                    protectVerseSource(input)
+                :   undefined;
+            const output = await prettier.format(protectedSource?.markdown ?? input, options);
+            return formatNoteFrontmatter(
+                protectedSource ? protectedSource.restore(output) : output,
+            );
+        };
+
         // A file Prettier cannot parse is a finding, not a crash. Its own CLI
         // reports the syntax error and carries on to the next file, and a
         // single unparseable file in a large tree must not cost the report on
@@ -172,7 +184,7 @@ export async function checkFormatting(root, opts = {}) {
                 let formatted = source;
                 let converged = false;
                 for (let pass = 0; pass < MAX_FORMAT_PASSES; pass += 1) {
-                    const next = formatNoteFrontmatter(await prettier.format(formatted, options));
+                    const next = await format(formatted);
                     if (next === formatted) {
                         converged = true;
                         break;
@@ -206,7 +218,7 @@ export async function checkFormatting(root, opts = {}) {
                 continue;
             }
 
-            if (formatNoteFrontmatter(await prettier.format(source, options)) !== source) {
+            if ((await format(source)) !== source) {
                 findings.push({
                     file,
                     severity: "error",

package/engine/run-rows.mjs

@@ -12,7 +12,7 @@
  */
 
 /**
- * Spans, divs and verse fences marked with `lang=`, `font=` or `enc=`, projected
+ * Spans, divs and verse divs and quoted verse spans marked with `lang=`, `font=` or `enc=`, projected
  * from own-note index records into the SQL `runs` relation. Every value is a
  * 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.

package/engine/sql-tables.mjs

@@ -682,7 +682,7 @@ async function createNameRelation(connection, file, records, prefix, audience) {
 }
 
 /**
- * Create the `runs` relation: one row per span, div and verse fence an own
+ * Create the `runs` relation: one row per span, div and verse div an own
  * note marks with `lang=`, `font=` or `enc=`, with the columns
  * {@link module:engine/run-rows.RUN_COLUMNS} names. The columns are declared
  * rather than inferred, so every value stays a string and none becomes a

package/engine/verse-format.mjs

@@ -0,0 +1,77 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/** Preserve complete authored verse regions through surrounding prose formatting. @module */
+
+import { verseRegions } from "./verse-regions.mjs";
+import { scanSpans } from "./content-spans.mjs";
+
+/**
+ * Replace verse markup with opaque placeholders and restore its original bytes.
+ * @param {string} source - Complete Markdown source.
+ * @returns {{markdown: string, restore: (formatted: string) => string}} Protected source and exact restoration.
+ */
+export function protectVerseSource(source) {
+    const syntax = source.replace(/^\uFEFF?---\r?\n[^]*?\r?\n---(?:\r?\n|$)/, (frontmatter) =>
+        frontmatter.replace(/[^\r\n]/g, " "),
+    );
+    const ranges = [
+        ...verseRegions(syntax)
+            .filter((region) => region.closed)
+            .map((region) => ({ from: region.from, to: region.to, block: true })),
+        ...scanSpans(syntax)
+            .spans.filter((span) =>
+                span.attrs.some(
+                    ([key, value]) => key === "class" && value.split(/\s+/).includes("verse"),
+                ),
+            )
+            .map((span) => ({ from: span.start, to: span.end, block: false })),
+    ].sort((a, b) => a.from - b.from || b.to - a.to);
+    const outer = ranges.filter(
+        (range, index) =>
+            !ranges
+                .slice(0, index)
+                .some((parent) => parent.from <= range.from && parent.to >= range.to),
+    );
+    let prefix = "VERSEPROTECTEDTOKEN";
+    while (source.includes(prefix)) prefix += "X";
+    const replacements = outer.map((range, index) => {
+        const original = source.slice(range.from, range.to);
+        const marker = range.block ? `<!--${prefix}${index}-->` : `${prefix}${index}END`;
+        return { ...range, original, marker, newline: range.block && /\r?\n$/.test(original) };
+    });
+    let markdown = source;
+    for (const entry of [...replacements].reverse())
+        markdown =
+            markdown.slice(0, entry.from) +
+            entry.marker +
+            (entry.newline ? "\n" : "") +
+            markdown.slice(entry.to);
+    return {
+        markdown,
+        restore(formatted) {
+            let restored = formatted;
+            for (const entry of replacements) {
+                const escaped = entry.marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                const pattern =
+                    entry.block ?
+                        new RegExp(`^[ \t]*${escaped}${entry.newline ? "\\r?\\n" : ""}`, "m")
+                    :   new RegExp(escaped);
+                if (!pattern.test(restored))
+                    throw new Error("the formatter changed a protected verse placeholder");
+                restored = restored.replace(pattern, () => entry.original);
+            }
+            return restored;
+        },
+    };
+}

package/engine/verse-metre.mjs

@@ -12,7 +12,7 @@
  */
 
 /**
- * **A verse fence declares its metre, and the build counts its beats.** A
+ * **A verse div declares its metre, and the build counts its beats.** A
  * metre is declared once, as an entry of a `doc` note's `data.metres`:
  *
  * ```yaml
@@ -21,7 +21,7 @@
  *     - { name: hexameter, beats: 6, kind: accentual }
  * ```
  *
- * A fence that states `scan=` with the `name` and `lang=` with a language
+ * A div that states `scan=` with the `name` and `lang=` with a language
  * whose note states `data.sounds.stress` is counted line by line, and a line
  * that cannot have the metre's beats is a warning at that line. No `scan=`
  * means no check.
@@ -278,7 +278,7 @@ export function lineBeats(text, book) {
  * The warning for a line that cannot have its metre's beats.
  *
  * @param {{min: number, max: number}} beats - The line's beats.
- * @param {import("./metre-declaration.mjs").Metre} metre - The fence's metre.
+ * @param {import("./metre-declaration.mjs").Metre} metre - The div's metre.
  * @returns {string} The message.
  */
 export function metreMessage({ min, max }, metre) {
@@ -287,13 +287,13 @@ export function metreMessage({ min, max }, metre) {
 }
 
 /**
- * Check the verse fences that state `scan=`.
+ * Check the verse divs that state `scan=`.
  *
  * @param {ReadonlyArray<{start: number, end: number, indent: string, attributes: Record<string, string>, classes: string[]}>} blocks -
- *   The fences, from {@link module:engine/content-verse.scanVerse}.
+ *   The divs, from {@link module:engine/content-verse.scanVerse}.
  * @param {string[]} lines - The source's lines.
  * @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
+ *   The metres and books, and how the div says its columns and where its
  *   keys sit.
  * @returns {{errors: object[], warnings: object[]}} The findings at 1-based
  *   positions.
@@ -325,7 +325,7 @@ export function metreFindings(blocks, lines, ctx) {
         if (lang === undefined) {
             error(
                 at("scan", "key"),
-                "`scan=` counts beats by a language's stress rule: the fence needs a `lang=`",
+                "`scan=` counts beats by a language's stress rule: the div needs a `lang=`",
             );
             continue;
         }
@@ -351,7 +351,16 @@ export function metreFindings(blocks, lines, ctx) {
         for (const group of model.groups) {
             if (group.cantoBreak) continue;
             for (const reading of group.lines) {
-                const tokens = verseParser.parseInline(reading.text, {})[0]?.children ?? [];
+                const units = reading.text
+                    .split("")
+                    .map((text, index) => ({ text, offset: reading.offsets[index] }))
+                    .filter(
+                        ({ offset }) =>
+                            !model.layout.some(([from, to]) => offset >= from && offset < to),
+                    );
+                const tokens =
+                    verseParser.parseInline(units.map((unit) => unit.text).join(""), {})[0]
+                        ?.children ?? [];
                 const tag = (name) => (ctx.languages?.[name]?.tag ?? name).toLowerCase();
                 const foreign = tokens.find(
                     (token) =>
@@ -361,7 +370,7 @@ export function metreFindings(blocks, lines, ctx) {
                 );
                 if (foreign) {
                     error(
-                        sourcePosition(reading.offsets[foreign.meta.start] ?? reading.from),
+                        sourcePosition(units[foreign.meta.start]?.offset ?? reading.from),
                         "`scan=` counts one language's beats; this verse line contains another language",
                     );
                     continue;