@heroiclands/package-build 25.3.0 → 25.5.0

package/engine/encoding-standard.mjs

@@ -27,6 +27,7 @@ export const STANDARD_ROWS = Object.freeze(
         ["—", "\u{E010A}"],
         ["…", "\u{E010B}"],
         ["/", "\u{E010C}"],
+        ["\\/", "\u{E010F}"],
         ["{", "\u{E0110}"],
         ["}", "\u{E0111}"],
     ].map(Object.freeze),

package/engine/encoding-template.mjs

@@ -207,7 +207,7 @@ export function templateProgram(data, options, fault) {
             fault(key, "Grave accents are forbidden");
     };
     const validateOutput = (from, to, key) => {
-        if (/[\u{E010D}\u{E010E}\u{E0112}\u{E0113}\u{E0115}]/u.test(to))
+        if (/[\u{E010D}-\u{E010F}\u{E0112}\u{E0113}\u{E0115}]/u.test(to))
             fault(key, "Structural controls cannot be mapping outputs");
         if (from.normalize("NFD").includes("\u0301") && stress) {
             const plain = from.normalize("NFD").replaceAll("\u0301", "").normalize("NFC");
@@ -343,7 +343,10 @@ export function templateProgram(data, options, fault) {
         definition: {
             name: "encoding-note",
             fonts: [data.font],
-            accepts: [...accepts, ...STANDARD_ROWS.map((r) => (Array.isArray(r) ? r[0] : r.from))],
+            accepts: [
+                ...accepts,
+                ...STANDARD_ROWS.flatMap((r) => [...(Array.isArray(r) ? r[0] : r.from)]),
+            ],
             separator: " ",
             roundTrip: canonical ? "canonical" : "exact",
             vowels,

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: "--- {.canto}", to: controls.verseCanto });
+    if (controls.verseCanto) controlRows.push({ from: "***", to: controls.verseCanto });
     const shared = tier(sharedRows, [], [...prefix, ...controlRows]);
     const faces = new Map();
     if (d.faces !== undefined && !object(d.faces))
@@ -270,7 +270,7 @@ export function compileRows(definition, metadata = {}) {
             tier(
                 rows(face.rows ?? [], `faces.${font}.rows`, vowels, d.roundTrip === "canonical"),
                 sharedRows,
-                prefix,
+                [...prefix, ...controlRows],
             ),
         );
     }
@@ -330,10 +330,10 @@ function beforeHolds(condition, char, vowels) {
 function holds(row, text, start, end, vowels) {
     if (row.before && !beforeHolds(row.before, firstAt(text, end), vowels)) return false;
     if (row.at === "line-start") {
-        const prefix = text.slice(
-            Math.max(text.lastIndexOf("\n", start - 1), text.lastIndexOf("/", start - 1)) + 1,
-            start,
-        );
+        let slash = text.lastIndexOf("/", start - 1);
+        while (slash >= 0 && (/\\+$/.exec(text.slice(0, slash))?.[0].length ?? 0) % 2)
+            slash = text.lastIndexOf("/", slash - 1);
+        const prefix = text.slice(Math.max(text.lastIndexOf("\n", start - 1), slash) + 1, start);
         if (prefix.replaceAll("^", "")) return false;
     }
     if (row.at === "start" && start > 0 && !boundary(previousAt(text, start))) return false;
@@ -514,8 +514,7 @@ function encodeRawPieces(enc, text, { font, verse = false, start = 0, end = text
             out.push(piece(text.slice(at, end), enc.controls.verseCanto, at, end, null));
             at = end;
             if (verse) {
-                if (text.startsWith("\r\n", at)) at += 2;
-                else if (/[\r\n]/.test(text[at] ?? "")) at++;
+                while (at < bound && /[ \t\r\n]/.test(text[at])) at++;
             }
             continue;
         }
@@ -523,10 +522,6 @@ function encodeRawPieces(enc, text, { font, verse = false, start = 0, end = text
             let end = at;
             while (end < bound && /[ \t\r\n]/.test(text[end])) end++;
             const run = text.slice(at, end).replaceAll("\r\n", "\n").replaceAll("\r", "\n");
-            if (text.startsWith("--- {.canto}", end)) {
-                at = end;
-                continue;
-            }
             const row =
                 run.split("\n").length === 2 ?
                     rowAt(enc, groups, "/", 0)
@@ -614,12 +609,22 @@ function sourceProjection(enc, text, options) {
     return { normalized, sourceAt, begin, bound };
 }
 function cantoEnd(enc, text, at, bound) {
-    const source = "--- {.canto}";
+    const source = "***";
     return (
             enc.controls.verseCanto &&
                 at + source.length <= bound &&
                 text.startsWith(source, at) &&
-                !text.slice(text.lastIndexOf("\n", at - 1) + 1, at).trim()
+                !text
+                    .slice(
+                        Math.max(text.lastIndexOf("\n", at - 1), text.lastIndexOf("\r", at - 1)) +
+                            1,
+                        at,
+                    )
+                    .trim() &&
+                !text
+                    .slice(at + source.length, bound)
+                    .split(/[\r\n]/, 1)[0]
+                    .trim()
         ) ?
             at + source.length
         :   undefined;

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/markdownlint-run.mjs

@@ -51,6 +51,7 @@ import {
     printParseErrorCode,
 } from "jsonc-parser";
 import markdownIt from "markdown-it";
+import footnotePlugin from "markdown-it-footnote";
 import { minimatch } from "minimatch";
 import { LineCounter, parse as parseYaml, parseDocument } from "yaml";
 
@@ -62,6 +63,13 @@ import {
     resolveModule,
 } from "../vendor/markdownlint.mjs";
 import { walkFiles } from "./walk-files.mjs";
+import { verseRegions } from "./verse-regions.mjs";
+import { scanSpans, spanMarkdownPlugin } from "./content-spans.mjs";
+import { parseVerse } from "./content-verse.mjs";
+import { footnoteLabels, footnoteReferences } from "./content-footnotes.mjs";
+
+/** References inside verse obey inline Markdown, without block interpretation. */
+const referenceParser = markdownIt({ html: true }).use(footnotePlugin).use(spanMarkdownPlugin);
 
 /** Option-file names, in the order the first existing one is taken. */
 const OPTIONS_FILES = Object.freeze([
@@ -542,12 +550,33 @@ export async function runMarkdownlint(params) {
     for (const [dir, files] of groups) {
         const options = await lintOptions(dir, files);
         const malformed = new Set();
+        const sources = new Map();
         for (const file of files) {
-            const findings = markupFindings(fs.readFileSync(file, "utf8"), file);
+            const source = fs.readFileSync(file, "utf8");
+            sources.set(file, protectLintVerse(source));
+            const findings = markupFindings(source, file);
             if (findings.length) malformed.add(file);
             markup.push(...findings);
         }
-        let results = await lint(options);
+        const lintSources = async (selected) => {
+            const { files: _files, ...shared } = options;
+            const results = await lint({
+                ...shared,
+                strings: Object.fromEntries(selected.map((file) => [file, sources.get(file).text])),
+            });
+            for (const file of selected) {
+                const protectedSource = sources.get(file);
+                results[file] = (results[file] ?? [])
+                    .filter((error) => !protectedSource.containsFinding(error))
+                    .map((error) => {
+                        if (!error.fixInfo || !protectedSource.containsFix(error)) return error;
+                        const { fixInfo: _fixInfo, ...unfixable } = error;
+                        return unfixable;
+                    });
+            }
+            return results;
+        };
+        let results = await lintSources(files);
         if (fix) {
             const toFix = [];
             for (const file of files) {
@@ -555,11 +584,15 @@ export async function runMarkdownlint(params) {
                 const fixable = (results[file] ?? []).filter((error) => error.fixInfo);
                 if (!fixable.length) continue;
                 const original = fs.readFileSync(file, "utf8");
-                fs.writeFileSync(file, applyFixes(original, fixable), "utf8");
+                const fixed =
+                    sources.get(file).protected ?
+                        applyVerseSafeFixes(original, fixable)
+                    :   applyFixes(original, fixable);
+                fs.writeFileSync(file, fixed, "utf8");
+                sources.set(file, protectLintVerse(fixed));
                 toFix.push(file);
             }
-            if (toFix.length)
-                results = { ...results, ...(await lint({ ...options, files: toFix })) };
+            if (toFix.length) results = { ...results, ...(await lintSources(toFix)) };
         }
         for (const [file, errors] of Object.entries(results)) resultsByFile.set(file, errors);
     }
@@ -581,3 +614,155 @@ export async function runMarkdownlint(params) {
     );
     return { results: flat, markup };
 }
+
+/**
+ * Hide verse content from Markdown rules and inline configuration without moving
+ * any authored coordinate. Container prefixes and div delimiters remain visible.
+ * @param {string} source - Original file contents.
+ * @returns {object} Masked text and predicates guarding findings and fixes.
+ */
+function protectLintVerse(source) {
+    const syntax = source.replace(/^\uFEFF?---\r?\n[^]*?\r?\n---(?:\r?\n|$)/, (frontmatter) =>
+        frontmatter.replace(/[^\r\n]/g, " "),
+    );
+    const starts = [0];
+    for (const match of source.matchAll(/\r\n|\r|\n/g)) starts.push(match.index + match[0].length);
+    const endOfLine = (line) => {
+        const past = starts[line + 1] ?? source.length;
+        return past - (/\r\n$|[\r\n]$/.exec(source.slice(starts[line], past))?.[0].length ?? 0);
+    };
+    const ranges = [],
+        masks = [],
+        inlineMasks = [],
+        spanBrackets = [],
+        bodyLines = new Set(),
+        verseLines = [],
+        usedReferences = new Set(),
+        footnotes = footnoteLabels(syntax);
+    const referencesInVerse = (text, model) => {
+        const titles = model.groups
+            .filter((group) => group.cantoBreak && group.title)
+            .map((group) => group.title);
+        for (const fragment of [text, ...titles])
+            for (const reference of footnoteReferences(fragment, {
+                definitions: footnotes,
+                inline: true,
+            }))
+                usedReferences.add(referenceParser.utils.normalizeReference(`^${reference.key}`));
+        for (const group of model.groups) {
+            if (group.cantoBreak) {
+                if (group.title) verseLines.push(group.title);
+            } else for (const line of group.lines) verseLines.push(line.text);
+        }
+    };
+    for (const region of verseRegions(syntax)) {
+        if (!region.closed) continue;
+        referencesInVerse(region.body, parseVerse(region.body, { footnotes }));
+        ranges.push([region.bodyStart, starts[region.end]]);
+        for (let line = region.start + 1; line < region.end; line++) {
+            bodyLines.add(line + 1);
+            masks.push([
+                Math.min(region.contentStarts[line - region.start], endOfLine(line)),
+                endOfLine(line),
+            ]);
+        }
+    }
+    for (const span of scanSpans(syntax).spans) {
+        if (!span.verseModel || source[span.end - 1] !== "}") continue;
+        referencesInVerse(span.text, span.verseModel);
+        ranges.push([span.start + 1, span.contentEnd]);
+        spanBrackets.push(span.start, span.contentEnd);
+        // Inline tokens omit quote/list prefixes. Continuation content ends
+        // at its physical line ending (or the located closing bracket), so
+        // its parsed length gives the content start without parsing prefixes.
+        const contentLines = span.text.replace(/\r\n?/g, "\n").split("\n");
+        for (const [index, content] of contentLines.entries()) {
+            const line = span.line - 1 + index;
+            const to = Math.min(endOfLine(line), span.contentEnd);
+            inlineMasks.push([index === 0 ? span.start + 1 : to - content.length, to]);
+        }
+    }
+    const raw = source.split("");
+    for (const [from, to] of masks)
+        for (let at = from; at < to; at++) if (!/[\r\n]/.test(raw[at])) raw[at] = " ";
+    // A blanked physical span line would split its surrounding paragraph.
+    // Neutralize its bracket delimiters too, so the mask cannot manufacture
+    // a reference shortcut to an unrelated definition with the same label.
+    for (const [from, to] of inlineMasks)
+        for (let at = from; at < to; at++) if (/\S/.test(raw[at])) raw[at] = "x";
+    for (const at of spanBrackets) raw[at] = "x";
+    const masked = raw.join("");
+    if (ranges.length) {
+        const env = {};
+        referenceParser.parse(masked, env);
+        // Reference links and images carry their normalized definition label
+        // on the actual emitted token. Speculative parser lookups do not count.
+        const collect = (tokens) => {
+            for (const token of tokens) {
+                const label = token.meta?.label;
+                if (["link_open", "image"].includes(token.type) && label) usedReferences.add(label);
+                if (token.children) collect(token.children);
+            }
+        };
+        for (const line of verseLines) {
+            const tokens = [];
+            referenceParser.inline.parse(line, referenceParser, env, tokens);
+            collect(tokens);
+        }
+    }
+    const intersects = (from, to) => ranges.some(([start, end]) => from < end && to > start);
+    return {
+        text: masked,
+        protected: ranges.length > 0,
+        containsFinding(error) {
+            if (error.ruleNames.includes("MD053")) {
+                const unused = /^Unused link or image reference definition: "([^]*)"$/.exec(
+                    error.errorDetail ?? "",
+                );
+                if (
+                    unused &&
+                    usedReferences.has(referenceParser.utils.normalizeReference(unused[1]))
+                )
+                    return true;
+            }
+            if (bodyLines.has(error.lineNumber)) return true;
+            if (!error.errorRange) return false;
+            const from = starts[error.lineNumber - 1] + error.errorRange[0] - 1;
+            return intersects(from, from + error.errorRange[1]);
+        },
+        containsFix(error) {
+            const fix = error.fixInfo;
+            const line = (fix.lineNumber || error.lineNumber) - 1;
+            const from = starts[line] + (fix.editColumn || 1) - 1;
+            if (fix.deleteCount === -1)
+                return intersects(starts[line], starts[line + 1] ?? source.length);
+            if (intersects(from, from + (fix.deleteCount ?? 0))) return true;
+            return Boolean(
+                fix.insertText && ranges.some(([start, end]) => from >= start && from <= end),
+            );
+        },
+    };
+}
+
+/**
+ * Apply fixes per original line so fixing prose cannot normalize the untouched
+ * line endings of a verse region elsewhere in a mixed-ending file.
+ * @param {string} source - Original file contents.
+ * @param {object[]} errors - Findings whose fixes do not intersect verse.
+ * @returns {string} Source with only the permitted fixes applied.
+ */
+function applyVerseSafeFixes(source, errors) {
+    const byLine = new Map();
+    for (const error of errors) {
+        const line = error.fixInfo.lineNumber || error.lineNumber;
+        if (!byLine.has(line)) byLine.set(line, []);
+        byLine
+            .get(line)
+            .push({ ...error, lineNumber: 1, fixInfo: { ...error.fixInfo, lineNumber: 1 } });
+    }
+    let line = 0;
+    return source.replace(/[^\r\n]*(?:\r\n|\r|\n|$)/g, (original) => {
+        const fixes = byLine.get(++line);
+        return fixes ? applyFixes(original, fixes) : original;
+    });
+}

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).",
             },