@heroiclands/package-build 25.4.0 → 25.5.1

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @heroiclands/package-build
 
+## 25.5.1
+
+**Builds and commands**
+
+- `package-build markdown` checks a repository of any size, rather than crashing on large ones.
+
+## 25.5.0
+
+**Languages and scripts**
+
+- A `.`, `?`, `‼` or `!` placed at the start of a sentence in invented-language roman is reported at that mark.
+
+**Verse**
+
+- A `--- {.canto}` break keeps the stanza break before it and decodes back without adding an extra line ending.
+- Inline `[…]{.verse}` keeps repeated and trailing `//` stanza marks alongside its `/` line marks and footnotes, including in files with CRLF line endings.
+- A literal `\/` in verse stays inside its line and decodes with its backslash intact.
+- A link inside verse is written in the link label's own language, not the verse's.
+- A verse line that looks like a footnote definition or a code fence stays ordinary verse text instead of raising a footnote error or swallowing what follows.
+- A scroll placed after verse renders and reports its own findings correctly, whichever line endings the file uses.
+- A nested shorthand verse div takes the language of the verse around it and shows no stray attribute text on the page.
+- Verse findings inside lists and block quotes point to the verse's opening mark, and leave out the column when the position is unknown.
+- `package-build format` keeps block quotes that contain verse, aligns tables that quote verse, and gives each document one consistent line ending.
+- `package-build markdown` leaves verse untouched while still checking and fixing the prose around it.
+- The authoring guide describes verse scansion and the warnings for names as the build applies them.
+
+**Upgrading**
+
+- Move any `.`, `?`, `‼` or `!` that opens a sentence in invented-language roman to the end of that sentence.
+
 ## 25.4.0
 
 **Verse**

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

@@ -598,7 +598,8 @@ indentation and source-line joining as a div. It takes ordinary span attributes,
 including `lang=` and `enc=`. An unencoded quotation draws Roman text with its
 line and stanza layout. A concrete encoding draws only its script, continuously
 inside the surrounding prose, like any encoded span. Its `/` and `//` reach the
-encoder as verse controls, so a script with verse signs draws them. Only divs
+encoder as verse controls, so a script with verse signs draws them. Consecutive
+stanza endings and a trailing stanza ending each retain their control. Only divs
 have paired script and Roman columns.
 Inline verse has no `work=`, `form=`, `scan=`, stanza labels or canto breaks.
 Directions, speaker labels, links, names and shared note footnotes work inside it.
@@ -663,8 +664,14 @@ The captain raises the lamp.
 The heading appears once across an encoded div's presentations. Its title is
 heading text, separate from the letters passed to the encoder. A valid break
 supplies the encoder's standard Roman `***` canto control. `package-build format`
-leaves each complete verse div and quotation byte for byte, including its
-delimiters and attributes, while formatting surrounding prose.
+preserves each verse div and quotation's text, spacing, delimiters and
+attributes while formatting surrounding prose. Quote and list
+containers remain intact, table columns use inline verse's authored width, and
+verse follows the same configured line endings as surrounding prose.
+
+The stanza mark before a canto is retained; whitespace after its encoded
+control adds no extra line mark. An encoded literal `\/` uses a separate
+invisible mark and decodes to `\/`, keeping it distinct from a line ending.
 
 #### Directions and speakers
 

package/docs/commands.md

@@ -2574,6 +2574,12 @@ overrides the rules and the ignore list; an option the file cannot mean is
 refused as `file:line:column: error:` and nothing is linted. See
 [Project setup](project-setup.md) for the accepted keys.
 
+Closed `.verse` div bodies and inline `.verse` quotation contents are excluded
+from Markdown rules and inline lint directives. Their authored bytes stay
+unchanged under `--fix`, including their line endings. The div's opening and
+closing lines and surrounding prose are still checked, with diagnostics at
+their original source locations. Verse markup validation remains active.
+
 **OPTIONS**
 
 | Positional | Type      | Default                               | Description                     |

package/docs/encoding-core.md

@@ -136,9 +136,15 @@ encoding has its Roman forms checked against the lettered one only.
 English names under a language's `data.names.en` are not encoded and are not
 checked against any encoding.
 
-Every encoding inherits the shared standard's fifteen Roman punctuation
+Every encoding inherits the shared standard's Roman punctuation
 mappings, verse and name controls, and literal boundaries. `‼` marks an
-imperative and `!` an exclamation. An explicit mapping can give a standard
+imperative and `!` an exclamation. Configured language runs require sentence
+text before each terminal (`.`, `?`, `‼`, `!`). Validation reports an opening
+terminal at its original source position, including escaped marks. Whitespace,
+indentation and verse boundaries preserve sentence state; opening quotations
+start their own sentence, and closing quotations contribute their enclosed
+text to the surrounding sentence. Names, literal codage and independent
+language children count as text. An explicit mapping can give a standard
 source its own font glyph. Other punctuation needs its own mapping.
 
 ## Conversion API
@@ -195,8 +201,16 @@ of the opening, closing or escape control are quoted with U+E0115; decoding
 unquotes them before reading their codes. Unknown codes, malformed escapes,
 nested markers and unmatched markers are errors.
 
-`{verse: true}` handles authored stanza and canto structure. The Markdown
-renderer additionally writes a boundary after every content line, including
+The shared `\/` row writes the nonprinting U+E010F literal-slash mark and
+decodes it to `\/`; `/` writes the distinct U+E010C line mark. Verse projection
+retains the escape until encoding, including inside inline quotations. A row
+program without a literal-slash row reports a source finding instead of
+substituting a line control. Ordinary mappings cannot emit U+E010F.
+
+`{verse: true}` handles line, stanza and canto structure. The encoder receives
+`***` for a canto and decodes U+E010E back to `***`. Whitespace before the canto
+still writes its stanza mark; following source whitespace adds no line mark.
+The Markdown renderer additionally writes a boundary after every content line, including
 the final line before a stanza or canto. Roman line layout is retained.
 
 The internal row conformance fixtures cover their captured source programs;

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

@@ -99,8 +99,11 @@ are supplied automatically. A language that lists uppercase letters accepts
 them; the build changes no authored case.
 
 The terminals are `.` for a statement, `?` for a question, `‼` for an imperative
-and `!` for an exclamation. None is required. A comma pauses within a sentence;
-use it instead of `;` or `:`, and use a period between complete sentences.
+and `!` for an exclamation. None is required. A terminal needs preceding text
+in its sentence; `! Vesun` is a finding at `!`, while `Vesun!` is valid.
+Whitespace, indentation, verse boundaries and a preceding terminal do not
+supply sentence text. A comma pauses within a sentence; use it instead of `;`
+or `:`, and use a period between complete sentences.
 Quotation pairs alternate `«…»`, `‹…›`, then `«…»` at successive depths.
 English double quotes, `<<` and `>>` are findings. A closing quote is not a
 terminal for the enclosing sentence.
@@ -117,6 +120,9 @@ blank lines or `//` end stanzas, and `--- {.canto}` after a blank line ends a ca
 slash is written `\/`. Indentation at a logical line boundary is layout,
 not a punctuation character added to the encoded words.
 
+An encoded literal slash has its own invisible mark, distinct from the verse
+line mark, and decodes to `\/`. It never ends the logical line.
+
 A `.name` child in a language run reaches the encoding with standard `{…}`
 name boundaries. An `.emph` child contributes the same letters with emphasis
 presentation. Both inherit the surrounding native writing when they state no
@@ -495,8 +501,10 @@ The keys are checked where they sit:
 
 A `.verse` div holds inline Markdown and explicit verse structure. It is opaque
 to lists, headings, quotes and code-block syntax. Its source newlines join unless
-`/` ends a logical line. The authoring formatter preserves the complete div and
-its attributes byte for byte, and also preserves inline `.verse` quotations.
+`/` ends a logical line. The authoring formatter preserves the div's text,
+spacing and attributes, and also preserves inline `.verse` quotations. Quote
+and list containers remain intact, table columns use the quotation's authored
+width, and verse follows the same configured line endings as surrounding prose.
 
 ```markdown
 ::: {.verse lang=vyl font=semaron-kuriale enc=vylsemaronenc}
@@ -505,11 +513,19 @@ Lokazor lonak./
 :::
 ```
 
+Both `:::verse` and `::: {.verse}` inherit the enclosing div's language when
+no `lang=` is stated. A link can select its label's language with trailing
+attributes: `[[lore-longtunnel|Zebra Quartz]]{lang=en}`. This overrides the verse
+language for the label while preserving the destination, including in an encoded
+original's script and Roman columns.
+
 Quoted verse is a span within prose, such as
 `[Lokazor lonak zaron./..Lokamen lonak zaron.//]{.verse lang=vyl}`.
 A concrete `enc=` sets a quotation in script only, continuously in the prose.
 Its `/` and `//` become the encoding's verse marks; only a div has paired script
-and Roman columns. An unencoded quotation keeps Roman line and stanza layout.
+and Roman columns. Each stanza ending contributes its control, including
+consecutive `//` marks and a final `//`. An unencoded quotation keeps Roman
+line and stanza layout.
 Quotations take no `work=`, `form=`, `scan=`, labels or canto breaks.
 A div's canto separator can carry a heading and an anchor:
 
@@ -526,6 +542,9 @@ 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.
+
 ### Versions of a work
 
 `form=epic` records the author's literary form without inferring layout or metre.
@@ -615,7 +634,7 @@ the second beats and, in brackets, with all of them:
 > ``this line has 4 beats (5 with secondary beats); the metre `hexameter` has 6``
 
 **The check is author-side.** Readers see nothing of it: the rendered div
-carries `data-metre` with the metre's name and nothing a reader sees. A div
+carries `data-scan` with the metre's name and nothing a reader sees. A div
 without `scan=` is not counted. `scan=` is refused where it cannot mean
 anything, each an error:
 

package/docs/reference/format-details.md

@@ -1994,9 +1994,9 @@ not.
 
 ##### Name-marking findings
 
-`package-build lint` reports two name-marking warnings in authored body prose.
-They leave a valid package passing. Headings, frontmatter, tables, infoboxes,
-code, comments and embeds are outside both.
+`package-build lint` reports one name-marking warning in authored body prose.
+It leaves a valid package passing. Headings, frontmatter, tables, infoboxes,
+code, comments and embeds are outside this check.
 
 1. A `.name` span without a `ref` whose whole text matches an indexed
    `name.full` or a form its `name` lists, ignoring case, should be a link or
@@ -2025,8 +2025,7 @@ valid inside emphasis:
 The name is `Joe Blow`; the surrounding phrase is emphasis.
 
 Each finding is one warning at its authored `file:line:column`, naming the
-full name or explicit label. A warning can describe both findings at one
-occurrence.
+full name or explicit label.
 
 An optional `data-type` on a `.name` span states what the named thing is:
 

package/engine/content-footnotes.mjs

@@ -114,12 +114,21 @@ const CONTAINER_PREFIX = /^(?:[ \t]{0,3}>[ \t]?|[ \t]{0,3}(?:[-*+]|\d{1,9}[.)])[
  */
 export function misplacedFootnoteDefinitions(source) {
     const lines = String(source ?? "").split("\n");
+    const verseLines = new Set(
+        verseRegions(String(source ?? "")).flatMap((region) =>
+            Array.from({ length: region.end - region.start + 1 }, (_, i) => region.start + i),
+        ),
+    );
     const errors = [];
     let fence = null;
     // Inside the continuation of a genuine top-level definition: a blank
     // line or a four-space indent belongs to it, not to a new mistake.
     let continuation = false;
     for (let i = 0; i < lines.length; i++) {
+        if (verseLines.has(i)) {
+            continuation = false;
+            continue;
+        }
         const line = lines[i];
         const marker = /^ {0,3}(`{3,}|~{3,})/.exec(line);
         if (fence) {

package/engine/content-scripts.mjs

@@ -1202,10 +1202,26 @@ function analyseRuns(source, ctx, syntax) {
             .map((span) => ({
                 bodyStart: span.start + 1,
                 bodyEnd: span.contentEnd,
-                body: span.text,
+                body: text.slice(span.start + 1, span.contentEnd),
                 model: span.verseModel,
             })),
     ];
+    // A reference with its own run keys is an independent child, just as
+    // the presentation span produced by the link resolver is. Keep its label
+    // out of the enclosing language and encoder without rewriting its target.
+    const independentReferences = rawReferences.filter(
+        (reference) =>
+            Object.keys(reference.construct.keys).length &&
+            verseContexts.some(
+                (poem) =>
+                    reference.where.start >= poem.bodyStart && reference.where.end <= poem.bodyEnd,
+            ),
+    );
+    const referenceSpans = independentReferences.map((reference) => ({
+        start: reference.where.start,
+        end: reference.where.end,
+        contentEnd: reference.to,
+    }));
     for (const poem of verseContexts) {
         const bodyStart = poem.bodyStart;
         for (const [from, to] of poem.model.layout)
@@ -1281,6 +1297,9 @@ function analyseRuns(source, ctx, syntax) {
                 .filter((reference) => reference.from >= from && reference.from < to)
                 .map((reference) => [reference.from, reference.to]),
             ...[...verseMarkers].filter(([start]) => start >= from && start < to),
+            ...independentReferences
+                .filter((reference) => reference.where.start >= from && reference.where.start < to)
+                .map((reference) => [reference.where.start, reference.where.end]),
             ...verseContexts
                 .filter(
                     (region) =>
@@ -1525,8 +1544,15 @@ function analyseRuns(source, ctx, syntax) {
 
         const first = construct.line0 + 1;
         const last = construct.last;
-        const from = starts[first] ?? text.length;
-        const to = last > first ? starts[last] - 1 : from;
+        // Verse regions retain authored UTF-16 bounds, including the full
+        // width of a CRLF terminator. A one-byte closing-line adjustment
+        // would leave CR outside the model and lose verse projection.
+        const from =
+            construct.kind === "verse" ? construct.node.bodyStart : (starts[first] ?? text.length);
+        const to =
+            construct.kind === "verse" ? construct.node.bodyEnd
+            : last > first ? starts[last] - 1
+            : from;
         detail.body = [from, to];
         detail.holes = holesIn(from, to);
 
@@ -1561,7 +1587,7 @@ function analyseRuns(source, ctx, syntax) {
                     said(
                         top,
                         token.info.trim().split(/\s/)[0] === "verse" ?
-                            "a verse div"
+                            "a code fence named `verse`; write a `::: {.verse}` div"
                         :   "a code fence",
                     );
                 else if (Object.hasOwn(BLOCK_WHAT, token.type)) said(top, BLOCK_WHAT[token.type]);
@@ -1629,7 +1655,12 @@ function analyseRuns(source, ctx, syntax) {
             ...noteReferences
                 .filter((reference) => reference.from >= bounds[0] && reference.from < bounds[1])
                 .map((reference) => [reference.from, reference.to]),
-            ...[...verseMarkers].filter(([start]) => start >= bounds[0] && start < bounds[1]),
+            ...[...verseMarkers].filter(
+                ([start]) =>
+                    start >= bounds[0] &&
+                    start < bounds[1] &&
+                    !referenceSpans.some((span) => start === span.start),
+            ),
             ...verseContexts
                 .filter(
                     (region) =>
@@ -1648,7 +1679,7 @@ function analyseRuns(source, ctx, syntax) {
         const projectionOptions = {
             from: bounds[0],
             to: bounds[1],
-            spans,
+            spans: [...spans, ...referenceSpans],
             exclude: excluded,
             includeSpan: (span) =>
                 spanDetails.has(span.start) && ownerOf(spanDetails.get(span.start)) === owner,
@@ -1744,12 +1775,25 @@ function analyseRuns(source, ctx, syntax) {
         }
         if (verse) {
             for (const boundary of projection.boundaries) {
-                const target =
-                    boundary.kind === "line" ?
-                        encodeText(owner.selection.encoding, "/", { font: owner.selection.font })
-                    :   owner.selection.encoding.controls[
-                            boundary.kind === "stanza" ? "verseStanza" : "verseCanto"
-                        ];
+                let target;
+                if (boundary.kind === "canto") {
+                    const encoded = encodeWithLanguage(owner.selection.encoding, "***", {
+                        font: owner.selection.font,
+                        lexicon: owner.selection.lexicon,
+                        verse: true,
+                    });
+                    for (const message of new Set(
+                        encoded.findings.map((finding) => finding.message),
+                    ))
+                        report(positionOf(starts, boundary.sourceOffset), message);
+                    target = encoded.text;
+                } else
+                    target =
+                        boundary.kind === "line" ?
+                            encodeText(owner.selection.encoding, "/", {
+                                font: owner.selection.font,
+                            })
+                        :   owner.selection.encoding.controls.verseStanza;
                 if (target === undefined) continue;
                 pieces.push({
                     from: "",
@@ -1798,6 +1842,17 @@ function analyseRuns(source, ctx, syntax) {
         });
     }
 
+    for (const reference of independentReferences) {
+        const book = ctx.wordBooks?.get(reference.lang);
+        if (!book) continue;
+        const projection = plainRomanRun(text, { from: reference.from, to: reference.to });
+        for (const problem of unknownWords(projection.text, book))
+            report(
+                positionOf(starts, projection.offsets[problem.offset] ?? reference.from),
+                unknownWordMessage(problem.word, reference.lang),
+            );
+    }
+
     const firstEncodingRun =
         active.find(native) ??
         rawReferences.find((reference) => native(reference.construct))?.construct;
@@ -2142,7 +2197,7 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
                 ...span,
                 inline: true,
                 model: span.verseModel,
-                body: span.text,
+                body: text.slice(span.start + 1, span.contentEnd),
                 bodyStart: span.start + 1,
                 bodyEnd: span.contentEnd,
             })),
@@ -2302,11 +2357,19 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
         if (attributes !== undefined) {
             const open = lines[run.start].indexOf("{");
             const close = lines[run.start].lastIndexOf("}");
-            edits.push({
-                from: starts[run.start] + open + 1,
-                to: starts[run.start] + close,
-                text: attributes,
-            });
+            if (open < 0 && run.kind === "verse") {
+                const opening = lines[run.start];
+                edits.push({
+                    from: starts[run.start] + opening.indexOf(":::"),
+                    to: starts[run.start] + opening.replace(/\r$/, "").length,
+                    text: `::: {${attributes}}`,
+                });
+            } else
+                edits.push({
+                    from: starts[run.start] + open + 1,
+                    to: starts[run.start] + close,
+                    text: attributes,
+                });
         }
         if (detail.plain && detail.body)
             for (const [from, to] of outsideHoles(detail.body[0], detail.body[1], detail.holes)) {
@@ -2395,7 +2458,7 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
             .map((span) => ({
                 ...span,
                 inline: true,
-                body: span.text,
+                body: markdown.slice(span.start + 1, span.contentEnd),
                 bodyStart: span.start + 1,
                 bodyEnd: span.contentEnd,
             })),
@@ -2469,7 +2532,10 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
         }
         for (const group of model.groups) {
             if (group.cantoBreak) {
-                group.text = detail.selection.encoding.controls.verseCanto ?? "";
+                group.text =
+                    detail.plan?.pieces.find(
+                        (piece) => piece.boundary === "canto" && piece.offset === base + group.from,
+                    )?.to ?? "";
                 continue;
             }
             for (const line of group.lines) {
@@ -2499,10 +2565,25 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
                 classes,
                 values: Object.entries(values).filter(([key]) => key !== "lang"),
             });
-            const native = model.groups
-                .flatMap((group) =>
-                    group.cantoBreak ? [group.text ?? ""] : group.lines.map((line) => line.text),
+            const fragments = model.groups.flatMap((group) =>
+                group.cantoBreak ? [{ from: group.from, text: group.text ?? "" }] : group.lines,
+            );
+            // Consecutive boundaries can stand between logical lines. They
+            // still contribute controls even when no line owns their offsets.
+            for (const piece of detail.plan?.pieces ?? []) {
+                if (!piece.boundary || piece.boundary === "canto") continue;
+                const offset = piece.anchor - base;
+                if (
+                    model.groups.some((group) =>
+                        group.lines.some((line) => offset >= line.from && offset <= line.to),
+                    )
                 )
+                    continue;
+                fragments.push({ from: offset, text: escapeRoman(piece.to, false) });
+            }
+            const native = fragments
+                .sort((a, b) => a.from - b.from)
+                .map((fragment) => fragment.text)
                 .join("");
             pairedEdits.push({
                 from: block.start,

package/engine/content-scroll.mjs

@@ -43,6 +43,7 @@
  */
 
 import { blockTokens } from "./markdown-blocks.mjs";
+import { verseRegions } from "./verse-regions.mjs";
 
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
 
@@ -114,7 +115,7 @@ function keyColumns(line, key) {
  * Read every `scroll` fence in a source, and every fault in its opening.
  *
  * A fence inside a block quote or an HTML block is not read, and neither is a
- * fence quoted inside another fence.
+ * fence quoted inside another fence. Verse lines are inline content.
  *
  * @param {string} source - Markdown.
  * @returns {{blocks: Scroll[], errors: Array<{line: number, column: number, message: string}>}}
@@ -125,8 +126,12 @@ export function scanScrolls(source) {
     const blocks = [];
     const errors = [];
     if (!/^ *(?:`{3,}|~{3,}) *scroll(?:\s|$)/m.test(text)) return { blocks, errors };
-    const lines = text.split("\n");
-    const literalLines = new Set();
+    const lines = text.split(/\r?\n/);
+    const literalLines = new Set(
+        verseRegions(text).flatMap((region) =>
+            Array.from({ length: region.end - region.start + 1 }, (_, i) => region.start + i),
+        ),
+    );
     for (const token of blockTokens(text)) {
         if (!token.map || !["blockquote_open", "html_block"].includes(token.type)) continue;
         for (let line = token.map[0]; line < token.map[1]; line++) literalLines.add(line);

package/engine/content-spans.mjs

@@ -67,7 +67,6 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false, verse
                 state.src[state.src.indexOf("]", start + 2) + 1] === "]") ||
             /@[A-Za-z]+$/.test(state.src.slice(0, start)) ||
             state.src[start + 1] === "^" ||
-            state.src[start + 1] === "!" ||
             ["!", "]"].includes(state.src[start - 1]) ||
             (state.src[start - 1] === "[" && state.linkLevel === 0)
         )
@@ -75,6 +74,7 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false, verse
         const end = state.md.helpers.parseLinkLabel(state, start, false);
         if (
             end < 0 ||
+            (state.src[start + 1] === "!" && state.src[end + 1] !== "{") ||
             ["(", "["].includes(state.src[end + 1]) ||
             (state.src[start + 1] === "[" && state.src[end + 1] !== "{")
         )
@@ -215,6 +215,7 @@ export function scanSpans(source) {
         tokens = parser.parse(text, env),
         spans = [],
         errors = [];
+    const sourcePositions = new Map();
     const lines = text.split("\n"),
         starts = [];
     let offset = 0;
@@ -244,6 +245,14 @@ export function scanSpans(source) {
                 if (children[close].type === "span_open") depth++;
                 if (children[close].type === "span_close" && --depth === 0) break;
             }
+            if ((child.attrGet("class") ?? "").split(/\s+/).includes("verse"))
+                sourcePositions.set(
+                    start,
+                    Array.from(
+                        { length: child.meta.text.length + 1 },
+                        (_, index) => position(child.meta.start + 1 + index) - start - 1,
+                    ),
+                );
             spans.push({
                 id: child.attrGet("id") ?? "",
                 line,
@@ -360,10 +369,34 @@ export function scanSpans(source) {
                 ([key, value]) => key === "class" && value.split(/\s+/).includes("verse"),
             )
         ) {
-            span.verseModel = parseVerse(span.text, {
+            const model = parseVerse(span.text, {
                 inline: true,
                 footnotes: footnoteLabels(text),
             });
+            // The parser removes container prefixes and normalizes CRLF. Map
+            // every logical range back through its original source positions.
+            const positions = sourcePositions.get(span.start);
+            const at = (offset) => positions[offset];
+            const ranges = new Set([
+                ...model.groups,
+                ...model.cantos.flatMap((canto) => canto.stanzas),
+                ...model.groups.flatMap((group) => (group.cantoBreak ? [] : group.lines)),
+                ...model.notes,
+            ]);
+            for (const range of ranges) {
+                range.from = at(range.from);
+                range.to = at(range.to);
+                if ("offsets" in range) range.offsets = range.offsets.map(at);
+            }
+            for (const boundary of model.boundaries)
+                boundary.sourceOffset = at(boundary.sourceOffset);
+            for (const finding of model.errors) finding.offset = at(finding.offset);
+            model.layout = model.layout.map(([from, to]) => [at(from), at(to)]);
+            for (let index = 1; index < positions.length; index++)
+                if (positions[index] > positions[index - 1] + 1)
+                    model.layout.push([positions[index - 1] + 1, positions[index]]);
+            model.layout.sort((a, b) => a[0] - b[0]);
+            span.verseModel = model;
             errors.push(...inlineVerseFindings(span, text));
         }
     spans.sort((a, b) => a.start - b.start);