@heroiclands/package-build 23.12.8 → 24.0.0

package/engine/content-scripts.mjs

@@ -13,18 +13,18 @@
 
 /**
  * **Text marked with a language, a font and a mapping.** Three keys on the
- * attribute grammar spans, divs and poetry fences already share, each optional
+ * attribute grammar spans, divs and verse fences already share, each optional
  * and independent of the others:
  *
  * ```markdown
  * [Daimela, helthos.]{lang=vyl}
- * [Zaron tholmeza]{lang=vyl font=semaron-kuriale map=vyl-semaron}
+ * [Zaron tholmeza]{lang=vyl font=semaron-kuriale map=semaron}
  *
- * ::: {lang=vyl font=semaron-kuriale map=vyl-semaron}
+ * ::: {lang=vyl font=semaron-kuriale map=semaron}
  * Zaron tholmeza.
  * :::
  *
- * ```poetry {form=epic lang=vyl font=semaron-kuriale map=vyl-semaron}
+ * ```verse {form=epic lang=vyl font=semaron-kuriale map=semaron}
  * ```
  *
  * - **`lang=`** gives the language tag and changes nothing else. It is a name
@@ -39,17 +39,25 @@
  * - **`lang=` with `map=` reads the language's lexicon first**: a word whose
  *   entry states a native form for the map is written by it, and the rows
  *   spell every other word; see {@link module:engine/map-lexicon}.
+ * - **A logographic map writes every word from the lexicon**: by the word's
+ *   own writing or its parts', and a word with neither, or whose form stands
+ *   for entries written differently, is a finding at the word, once per run;
+ *   see {@link module:engine/logographic}.
  * - **Every word of a run with `lang=` and `map=` is a word of its language**
  *   where the language's `note` names its language note: a lexicon form, a
  *   word of a name its own register lists, or a regular form of a lexicon
  *   form. Any other
  *   word is a finding at its first character, once per run; see
  *   {@link module:engine/run-words}.
- * - **A run inside a div or a poetry fence inherits its keys**, and its own
+ * - **A run inside a div or a verse fence inherits its keys**, and its own
  *   keys override them.
  * - **Text with a font, a map or a declared language is plain.** A span or a
  *   verse holds no emphasis, link, image, footnote, wikilink, code or HTML,
  *   and no span but a marked one; a div holds paragraphs and line breaks only.
+ * - **Text set in a face takes `*…*` and `**…**`**, set by the convention its
+ *   language's note states, else its face's script note, else plainly; see
+ *   {@link module:engine/script-emphasis}. A language that marks emphasis
+ *   with a word makes either a finding at the emphasis.
  *   The text is read as written, so `[`, `]`, `"`, `<<`, `>>`, `!` and
  *   `@#$%^&` are characters, and need no escaping. A real language's tag alone
  *   marks text and leaves its Markdown alone.
@@ -59,7 +67,7 @@
  *
  * {@link scanRuns} reads the markup through {@link module:engine/content-spans.scanSpans},
  * {@link module:engine/content-blocks.scanBlocks} and
- * {@link module:engine/content-poetry.scanPoetry}, so what counts as a span, a
+ * {@link module:engine/content-verse.scanVerse}, so what counts as a span, a
  * div or a fence is theirs to say.
  *
  * @module
@@ -68,18 +76,30 @@
 import MarkdownIt from "markdown-it";
 
 import { scanBlocks, BLOCK_CONTAINERS } from "./content-blocks.mjs";
-import { scanPoetry } from "./content-poetry.mjs";
+import {
+    COLUMN_KEYS,
+    COLUMNS_CLASS,
+    expandVerse,
+    expandVerseOrigins,
+    scanVerse,
+    sourcePosition,
+} from "./content-verse.mjs";
 import { scanSpans } from "./content-spans.mjs";
 import { isLanguageTag } from "./language-tag.mjs";
 import { distance, nearest } from "./near-miss.mjs";
+import { emphasesFromRecords, languageEmphasesOf } from "./script-emphasis.mjs";
+import { EMPHASIS_CLASSES } from "./script-emphasis-terms.mjs";
 import { FONTS_PACKAGE, resolveScriptFonts } from "./script-fonts.mjs";
 import {
     fontProblem,
+    languageRecordsByName,
     lexiconsFromRecords,
     mappingFor,
     uncapitalisedMessage,
+    unwrittenMessage,
 } from "./map-lexicon.mjs";
 import { unknownWordMessage, unknownWords, wordBooksFromRecords } from "./run-words.mjs";
+import { metreBooksFromRecords, metreFindings, metresFromRecords } from "./verse-metre.mjs";
 import { applyMap, mapsFromRecords } from "./text-maps.mjs";
 
 /** The keys this module reads, which no construct passes through as written. */
@@ -113,15 +133,26 @@ const CONFIG = "package-build.config.yaml";
  * @property {ReadonlyMap<string, import("./run-words.mjs").WordBook>} [wordBooks] -
  *   What each configured language's mapped runs are checked against, from
  *   {@link module:engine/run-words.wordBooksFromRecords}.
+ * @property {ReadonlyMap<string, import("./metre-declaration.mjs").Metre>} [metres] -
+ *   The metres the `doc` notes declare, by name.
+ * @property {ReadonlyMap<string, import("./verse-metre.mjs").MetreBook>} [metreBooks] -
+ *   What each configured language's verse is counted by, from
+ *   {@link module:engine/verse-metre.metreBooksFromRecords}.
+ * @property {ReadonlyMap<string, import("./script-emphasis.mjs").Emphasis>} [emphases] -
+ *   Each face's emphasis conventions, from the script notes, by
+ *   {@link module:engine/script-emphasis.emphasesFromRecords}.
+ * @property {ReadonlyMap<string, import("./script-emphasis.mjs").LanguageEmphasis>} [languageEmphases] -
+ *   The convention each configured language's note states, by language name,
+ *   from {@link module:engine/script-emphasis.languageEmphasesOf}.
  */
 
 /**
- * One span, div or poetry fence carrying `lang=`, `font=` or `map=`. Its
+ * One span, div or verse fence carrying `lang=`, `font=` or `map=`. Its
  * `lang`, `font` and `map` are the ones it is set with: its own, else the
  * innermost div or fence around it that states one.
  *
  * @typedef {object} Run
- * @property {"span"|"block"|"poetry"} kind - Which construct.
+ * @property {"span"|"block"|"verse"} kind - Which construct.
  * @property {string|undefined} lang - The language as written.
  * @property {string|undefined} tag - The BCP 47 tag it resolves to; `undefined`
  *   when it resolves to none.
@@ -181,6 +212,10 @@ export function runContext(config, records) {
         maps: mapsFromRecords(records),
         lexicons: lexiconsFromRecords(records, config),
         wordBooks: wordBooksFromRecords(records, config),
+        metres: metresFromRecords(records),
+        metreBooks: metreBooksFromRecords(records, config),
+        emphases: emphasesFromRecords(records),
+        languageEmphases: languageEmphasesOf(languageRecordsByName(records, config)),
     });
     byRecords.set(records, context);
     return context;
@@ -205,7 +240,7 @@ function withinOneEdit(a, b) {
 }
 
 /** The word each construct is called in a finding. */
-const CONSTRUCT = Object.freeze({ span: "span", block: "div", poetry: "poetry fence" });
+const CONSTRUCT = Object.freeze({ span: "span", block: "div", verse: "verse fence" });
 
 /** Line starts of a source, for offsets to positions. */
 function lineStarts(text) {
@@ -298,9 +333,11 @@ function closing(text, open) {
  * @param {ReadonlyMap<number, number>} [holes] - Marked spans inside the
  *   text, each its offset of `[` to the offset past its attributes. They are
  *   runs of their own and checked as such.
+ * @param {boolean} [stars] - Whether `*…*`, `_…_`, `**…**` and `__…__` are
+ *   emphasis the text may hold, as in a run in a script face; `~~` is not.
  * @returns {Array<{offset: number, what: string}>} Each fault, in order.
  */
-function inlineMarkup(text, footnotes, holes = new Map()) {
+function inlineMarkup(text, footnotes, holes = new Map(), stars = false) {
     const faults = [];
     const skip = new Map();
     const runs = [];
@@ -384,6 +421,10 @@ function inlineMarkup(text, footnotes, holes = new Map()) {
         if (char === "*" || char === "_" || (char === "~" && text[i + 1] === "~")) {
             let j = i;
             while (text[j] === char) j++;
+            if (stars && char !== "~") {
+                i = j - 1;
+                continue;
+            }
             const before = text[i - 1] ?? " ",
                 after = text[j] ?? " ";
             const left =
@@ -401,7 +442,7 @@ function inlineMarkup(text, footnotes, holes = new Map()) {
             i = j - 1;
         }
     }
-    let outside = text;
+    let outside = stars ? text.replace(/[*_]/g, " ") : text;
     for (const [from, to] of holes)
         outside = outside.slice(0, from) + " ".repeat(to - from) + outside.slice(to);
     if (runs.length && holdsEmphasis(outside)) {
@@ -422,6 +463,91 @@ function inlineMarkup(text, footnotes, holes = new Map()) {
     return faults.sort((a, b) => a.offset - b.offset);
 }
 
+/** A parser that reads emphasis and nothing else in text whose other punctuation is escaped. */
+const starParser = new MarkdownIt({ html: false, linkify: false, typographer: false });
+
+/** ASCII punctuation, which a backslash escapes. */
+const ASCII_PUNCTUATION = /[!-/:-@[-`{-~]/;
+
+/**
+ * One `*`, `_`, `**` or `__` that Markdown reads as opening or closing emphasis.
+ *
+ * @typedef {object} Delimiter
+ * @property {number} offset - Its first character's offset.
+ * @property {number} length - 1 for `*` or `_`, 2 for `**` or `__`.
+ * @property {"em"|"strong"} tag - Which level it opens or closes.
+ * @property {boolean} open - Whether it opens.
+ */
+
+/**
+ * The stars and underscores Markdown reads as emphasis in a run's text, as
+ * CommonMark pairs them. Every other character is read as itself: an escaped
+ * delimiter, or one that pairs with none, is a character of the text. A marked span inside the text
+ * reads as one letter, so emphasis may enclose it.
+ *
+ * @param {string} text - Inline text, as written.
+ * @param {ReadonlyMap<number, number>} [holes] - Marked spans inside it, by
+ *   offset in `text`.
+ * @returns {Delimiter[]} Each delimiter, in order, at its offset in `text`.
+ */
+function emphasisDelimiters(text, holes = new Map()) {
+    let masked = "";
+    const stars = [];
+    for (let i = 0; i < text.length; i++) {
+        if (holes.has(i)) {
+            masked += "x";
+            i = /** @type {number} */ (holes.get(i)) - 1;
+            continue;
+        }
+        const char = text[i];
+        if (char === "\\" && ASCII_PUNCTUATION.test(text[i + 1] ?? "")) {
+            masked += text[i + 1] === "*" || text[i + 1] === "_" ? "\\!" : `\\${text[i + 1]}`;
+            i++;
+        } else if (char === "*" || char === "_") {
+            masked += char;
+            stars.push(i);
+        } else masked += ASCII_PUNCTUATION.test(char) ? `\\${char}` : char;
+    }
+    if (!stars.length) return [];
+    const delimiters = [];
+    let at = 0;
+    for (const token of starParser.parseInline(masked, {})[0]?.children ?? []) {
+        if (token.type === "text") at += (token.content.match(/[*_]/g) ?? []).length;
+        else if (/^(?:em|strong)_(?:open|close)$/.test(token.type)) {
+            delimiters.push({
+                offset: stars[at],
+                length: token.markup.length,
+                tag: /** @type {"em"|"strong"} */ (token.tag),
+                open: token.nesting === 1,
+            });
+            at += token.markup.length;
+        }
+    }
+    return delimiters;
+}
+
+/**
+ * The parts of ranges of text that no delimiter covers.
+ *
+ * @param {Array<[number, number]>} parts - The ranges, as offsets.
+ * @param {readonly Delimiter[]} delimiters - Delimiters, by absolute offset.
+ * @returns {Array<[number, number]>} The ranges, split around each delimiter.
+ */
+function outsideDelimiters(parts, delimiters) {
+    if (!delimiters.length) return parts;
+    const out = [];
+    for (const [from, to] of parts) {
+        let at = from;
+        for (const delimiter of delimiters) {
+            if (delimiter.offset < at || delimiter.offset >= to) continue;
+            if (delimiter.offset > at) out.push([at, delimiter.offset]);
+            at = delimiter.offset + delimiter.length;
+        }
+        if (at < to) out.push([at, to]);
+    }
+    return out;
+}
+
 /** A line split into its indentation, its text, a trailing break and its trailing space. */
 const LINE_PARTS = /^(\s*)(.*?)(\\?)(\s*)$/;
 
@@ -474,7 +600,7 @@ function unescapeRoman(core) {
  * @param {import("./map-lexicon.mjs").Mapping|undefined} mapping - The run's
  *   map, face and lexicon.
  * @param {boolean} lineStart - Whether `raw` starts its line.
- * @returns {{text: string, pieces: Array<{offset: number, from: string, to: string, row: boolean, native?: boolean, uncapitalised?: string}>}}
+ * @returns {{text: string, pieces: Array<{offset: number, from: string, to: string, row: boolean, native?: boolean, uncapitalised?: string, unwritten?: object}>}}
  *   The set text, and each piece of it with the offset in `raw` it came from.
  */
 function setText(raw, mapping, lineStart) {
@@ -491,6 +617,7 @@ function setText(raw, mapping, lineStart) {
             const mapped = applyMap(mapping?.map, plain.text, {
                 font: mapping?.font,
                 native: mapping?.native,
+                writing: mapping?.writing,
             });
             for (const piece of mapped.pieces)
                 pieces.push({
@@ -502,6 +629,7 @@ function setText(raw, mapping, lineStart) {
                     ...(piece.uncapitalised === undefined ?
                         {}
                     :   { uncapitalised: piece.uncapitalised }),
+                    ...(piece.unwritten === undefined ? {} : { unwritten: piece.unwritten }),
                 });
             out.push(
                 lead +
@@ -574,7 +702,40 @@ const BLOCK_WHAT = Object.freeze({
  * @property {[number, number]|undefined} body - A div's or fence's body, as
  *   offsets: the first body line's start to the end of the last.
  * @property {number|undefined} contentEnd - A span's offset of its closing `]`.
+ * @property {import("./script-emphasis.mjs").LanguageEmphasis|undefined} languageEmphasis -
+ *   The convention its language's note states.
+ * @property {import("./script-emphasis.mjs").Emphasis|undefined} conventions -
+ *   What its emphasis is set by: its language's convention, else its face's
+ *   script's; `undefined` sets it plain.
+ * @property {Delimiter[]} emphasis - The emphasis it holds, by absolute offset.
+ */
+
+/**
+ * The finding for emphasis in a language that marks it with a word.
+ *
+ * @param {string} lang - The language, as `lang=` names it.
+ * @returns {string} The message.
+ */
+function wordsMessage(lang) {
+    return `\`${lang}\` marks emphasis with a word, not a mark; write the word`;
+}
+
+/**
+ * What a run's emphasis is set by: the convention its language's note states,
+ * else the one its face's script note states, else none. A language that
+ * marks emphasis with a word sets none, and its emphasis is a finding.
+ *
+ * @param {{face: import("./script-fonts.mjs").Face|undefined, languageEmphasis: string|undefined}} detail -
+ *   The run.
+ * @param {RunContext} ctx - The conventions.
+ * @returns {import("./script-emphasis.mjs").Emphasis|undefined} The conventions.
  */
+function conventionsOf({ face, languageEmphasis }, ctx) {
+    if (!face || languageEmphasis === "words") return undefined;
+    if (languageEmphasis === "rubric" || languageEmphasis === "overline")
+        return { em: languageEmphasis, strong: languageEmphasis };
+    return ctx.emphases?.get(face.slug);
+}
 
 /**
  * Read every marked construct in a source, and every fault in it.
@@ -645,7 +806,7 @@ function analyseRuns(source, ctx, syntax) {
                 for (const key of Object.keys(keys))
                     report(
                         at(key, "key"),
-                        `\`${key}=\` is read on a span, a div or a poetry fence, not on a ${block.name} block`,
+                        `\`${key}=\` is read on a span, a div or a verse fence, not on a ${block.name} block`,
                     );
             } else {
                 divs.set(first, block);
@@ -679,13 +840,13 @@ function analyseRuns(source, ctx, syntax) {
     collect(0, text);
 
     const poems = new Map();
-    for (const poem of scanPoetry(text).blocks) {
+    for (const poem of scanVerse(text).blocks) {
         poems.set(poem.start, poem);
         const keys = runKeys(poem.attributes);
         if (!Object.keys(keys).length) continue;
         const opening = lines[poem.start];
         constructs.push({
-            kind: "poetry",
+            kind: "verse",
             keys,
             node: poem,
             line0: poem.start,
@@ -790,25 +951,44 @@ function analyseRuns(source, ctx, syntax) {
         );
 
     /**
-     * Report the markup in inline text that must be plain.
+     * Report the markup in inline text that must be plain, and collect the
+     * emphasis a run in a script face holds.
      *
      * @param {string} inline - The text.
      * @param {number} offset - Its offset in the source.
      * @param {string} marking - How its construct is marked.
+     * @param {RunDetail} detail - The run, whose `emphasis` collects each
+     *   delimiter by absolute offset.
      * @param {ReadonlyMap<number, number>} [holes] - Marked spans in it, by
      *   absolute offset.
      */
-    const plainInline = (inline, offset, marking, holes = new Map()) => {
+    const plainInline = (inline, offset, marking, detail, holes = new Map()) => {
         const relative = new Map(
             [...holes]
                 .filter(([start]) => start >= offset && start < offset + inline.length)
                 .map(([start, end]) => [start - offset, end - offset]),
         );
-        for (const fault of inlineMarkup(inline, footnotes, relative))
+        const { lang } = detail.run;
+        const words = detail.languageEmphasis === "words";
+        const stars = words || detail.face !== undefined;
+        for (const fault of inlineMarkup(inline, footnotes, relative, stars))
             report(
                 positionOf(starts, offset + fault.offset),
-                `text marked \`${marking}\` is plain text and holds no ${fault.what}`,
+                fault.what !== "emphasis" || !stars ?
+                    `text marked \`${marking}\` is plain text and holds no ${fault.what}`
+                : words ? wordsMessage(/** @type {string} */ (lang))
+                : `text marked \`${marking}\` takes emphasis only as \`*…*\`, \`_…_\`, \`**…**\` or \`__…__\``,
             );
+        if (!stars) return;
+        for (const delimiter of emphasisDelimiters(inline, relative)) {
+            if (words) {
+                if (delimiter.open)
+                    report(
+                        positionOf(starts, offset + delimiter.offset),
+                        wordsMessage(/** @type {string} */ (lang)),
+                    );
+            } else detail.emphasis.push({ ...delimiter, offset: offset + delimiter.offset });
+        }
     };
 
     /**
@@ -825,6 +1005,8 @@ function analyseRuns(source, ctx, syntax) {
         for (const [from, to] of parts) {
             const lineStart = from === 0 || text[from - 1] === "\n";
             for (const piece of setText(text.slice(from, to), mapping, lineStart).pieces) {
+                // A word with no writing is its own finding, not a face's.
+                if (piece.unwritten) continue;
                 for (const char of piece.to) {
                     const point = /** @type {number} */ (char.codePointAt(0));
                     if (/\s/u.test(char) || face.draws.has(point)) continue;
@@ -884,6 +1066,35 @@ function analyseRuns(source, ctx, syntax) {
         }
     };
 
+    /**
+     * Report each word a logographic map gives no writing, once per run, at
+     * the word.
+     *
+     * @param {Array<[number, number]>} parts - The text to check, as offsets.
+     * @param {RunDetail} detail - The run.
+     */
+    const writings = (parts, detail) => {
+        const { mapping } = detail;
+        if (!mapping?.map.logographic) return;
+        const said = new Set();
+        for (const [from, to] of parts) {
+            const lineStart = from === 0 || text[from - 1] === "\n";
+            for (const piece of setText(text.slice(from, to), mapping, lineStart).pieces) {
+                if (piece.unwritten === undefined || said.has(piece.from)) continue;
+                said.add(piece.from);
+                report(
+                    positionOf(starts, from + piece.offset),
+                    unwrittenMessage(
+                        piece.from,
+                        piece.unwritten,
+                        detail.run.lang,
+                        mapping.map.name,
+                    ),
+                );
+            }
+        }
+    };
+
     /**
      * Report each word of a mapped run that is not a word of its language, once
      * per run, at its first character.
@@ -914,7 +1125,11 @@ function analyseRuns(source, ctx, syntax) {
     const runs = [];
     const details = [];
     for (const construct of constructs) {
+        const unchecked = errors.length;
         checkOwn(construct);
+        // A key that names nothing is the finding; the text it would have set
+        // is not then checked against a face or a language it cannot reach.
+        const named = errors.length === unchecked;
         const keys = Object.assign({}, ...around(construct).map((c) => c.keys), construct.keys);
         const { lang, font, map } = keys;
         // A face the run's map is not for, once the face and the map are each
@@ -959,7 +1174,11 @@ function analyseRuns(source, ctx, syntax) {
             holes: new Map(),
             body: undefined,
             contentEnd: construct.kind === "span" ? construct.node.contentEnd : undefined,
+            languageEmphasis: lang === undefined ? undefined : ctx.languageEmphases?.get(lang),
+            conventions: undefined,
+            emphasis: [],
         };
+        detail.conventions = conventionsOf(detail, ctx);
         details.push(detail);
         if (!plain) continue;
         const marking = [
@@ -972,11 +1191,16 @@ function analyseRuns(source, ctx, syntax) {
         if (construct.kind === "span") {
             const span = construct.node;
             const inline = text.slice(span.start + 1, span.contentEnd);
-            plainInline(inline, span.start + 1, marking);
-            if (errors.length === before) {
-                lexical([[span.start + 1, span.contentEnd]], detail);
-                capitals([[span.start + 1, span.contentEnd]], detail);
-                covered([[span.start + 1, span.contentEnd]], detail);
+            plainInline(inline, span.start + 1, marking, detail);
+            if (named && errors.length === before) {
+                const parts = outsideDelimiters(
+                    [[span.start + 1, span.contentEnd]],
+                    detail.emphasis,
+                );
+                lexical(parts, detail);
+                capitals(parts, detail);
+                writings(parts, detail);
+                covered(parts, detail);
             }
             continue;
         }
@@ -1010,6 +1234,7 @@ function analyseRuns(source, ctx, syntax) {
                             body.slice(top, past).join("\n"),
                             starts[first + top],
                             marking,
+                            detail,
                             detail.holes,
                         );
                     continue;
@@ -1017,20 +1242,22 @@ function analyseRuns(source, ctx, syntax) {
                 if (token.type === "fence")
                     said(
                         top,
-                        token.info.trim().split(/\s/)[0] === "poetry" ?
-                            "a poetry fence"
+                        token.info.trim().split(/\s/)[0] === "verse" ?
+                            "a verse fence"
                         :   "a code fence",
                     );
                 else if (Object.hasOwn(BLOCK_WHAT, token.type)) said(top, BLOCK_WHAT[token.type]);
             }
         } else {
             for (let line = first; line < last; line++)
-                plainInline(lines[line], starts[line], marking, detail.holes);
+                plainInline(lines[line], starts[line], marking, detail, detail.holes);
         }
-        if (errors.length === before) {
-            lexical(outsideHoles(from, to, detail.holes), detail);
-            capitals(outsideHoles(from, to, detail.holes), detail);
-            covered(outsideHoles(from, to, detail.holes), detail);
+        if (named && errors.length === before) {
+            const parts = outsideDelimiters(outsideHoles(from, to, detail.holes), detail.emphasis);
+            lexical(parts, detail);
+            capitals(parts, detail);
+            writings(parts, detail);
+            covered(parts, detail);
         }
     }
 
@@ -1043,7 +1270,7 @@ function analyseRuns(source, ctx, syntax) {
 }
 
 /**
- * Find the spans, divs and poetry fences marked with `lang=`, `font=` or
+ * Find the spans, divs and verse fences marked with `lang=`, `font=` or
  * `map=`, and every fault in their markup and their text.
  *
  * @param {string} source - Authored Markdown: a note body, or a whole file
@@ -1059,8 +1286,50 @@ function analyseRuns(source, ctx, syntax) {
  *   declared name.
  */
 export function scanRuns(source, ctx = {}, syntax) {
-    const { runs, errors, warnings } = analyseRuns(source, ctx, syntax);
-    return { runs, errors, warnings };
+    const text = String(source ?? "");
+    const { markdown, origins } = expandVerseOrigins(text);
+    const authored = analyseRuns(text, ctx, syntax);
+    const metre = metreFindings(scanVerse(text).blocks, text.split("\n"), {
+        metres: ctx.metres,
+        metreBooks: ctx.metreBooks,
+        lexicons: ctx.lexicons,
+        columnsClass: COLUMNS_CLASS,
+        columnKeys: COLUMN_KEYS,
+        attributeColumns,
+    });
+    /** @param {object[]} found @param {object[]} extra */
+    const merged = (found, extra) =>
+        extra.length ?
+            [...found, ...extra].sort((a, b) => a.line - b.line || a.column - b.column)
+        :   found;
+    if (markdown === text)
+        return {
+            ...authored,
+            errors: merged(authored.errors, metre.errors),
+            warnings: merged(authored.warnings, metre.warnings),
+        };
+    // A verse in columns is checked as the spans each entry sets, which are
+    // written only in the expansion; every finding is placed back where the
+    // note wrote the text or the entry it comes from, once.
+    const expanded = markdown.split("\n");
+    const checked = analyseRuns(markdown, ctx);
+    const placed = (findings) => {
+        const seen = new Set();
+        return findings
+            .map((finding) => ({ ...finding, ...sourcePosition(finding, expanded, origins) }))
+            .filter((finding) => {
+                const key = `${finding.line}:${finding.column}:${finding.message}`;
+                if (seen.has(key)) return false;
+                seen.add(key);
+                return true;
+            })
+            .sort((a, b) => a.line - b.line || a.column - b.column);
+    };
+    return {
+        runs: authored.runs,
+        errors: merged(placed(checked.errors), metre.errors),
+        warnings: merged(placed(checked.warnings), metre.warnings),
+    };
 }
 
 /**
@@ -1113,7 +1382,7 @@ function rewrittenAttributes(detail, search) {
     const changes =
         run.font !== undefined ||
         run.map !== undefined ||
-        (run.tag !== undefined && (keys.lang !== run.tag || run.kind === "poetry"));
+        (run.tag !== undefined && (keys.lang !== run.tag || run.kind === "verse"));
     if (!changes) return undefined;
     const classes = [...own.classes];
     const values = [...own.values];
@@ -1128,12 +1397,70 @@ function rewrittenAttributes(detail, search) {
     return attributeText({ lang: run.tag, id: own.id, classes, values });
 }
 
+/**
+ * The tag a delimiter is written as: an `<em>` or a `<strong>` carrying its
+ * convention's class. The book's parser reads only the classed form, so a
+ * delimiter with no convention writes nothing there, and the text is set in
+ * the face's Regular.
+ *
+ * @param {Delimiter} delimiter - The delimiter.
+ * @param {import("./script-emphasis.mjs").Emphasis|undefined} conventions -
+ *   The run's conventions.
+ * @param {boolean} book - Whether the target is the book.
+ * @returns {string} The tag.
+ */
+function emphasisTag(delimiter, conventions, book) {
+    const convention = conventions?.[delimiter.tag];
+    if (!convention && book) return "";
+    if (!delimiter.open) return `</${delimiter.tag}>`;
+    return convention ?
+            `<${delimiter.tag} class="${EMPHASIS_CLASSES[convention]}">`
+        :   `<${delimiter.tag}>`;
+}
+
+/**
+ * Set a range of a run's text, each piece between its emphasis delimiters by
+ * {@link setText}, and each delimiter as its tag.
+ *
+ * @param {string} text - The source.
+ * @param {number} from - The range's first offset.
+ * @param {number} to - The offset past it.
+ * @param {RunDetail} detail - The run.
+ * @param {boolean} lineStart - Whether `from` starts its line.
+ * @param {boolean} book - Whether the target is the book.
+ * @returns {string} The set text.
+ */
+function setRange(text, from, to, detail, lineStart, book) {
+    let out = "";
+    let at = from;
+    for (const delimiter of detail.emphasis) {
+        if (delimiter.offset < from || delimiter.offset >= to) continue;
+        if (delimiter.offset > at)
+            out += setText(
+                text.slice(at, delimiter.offset),
+                detail.mapping,
+                at === from && lineStart,
+            ).text;
+        out += emphasisTag(delimiter, detail.conventions, book);
+        at = delimiter.offset + delimiter.length;
+    }
+    if (at < to) out += setText(text.slice(at, to), detail.mapping, at === from && lineStart).text;
+    return out;
+}
+
 /**
  * Rewrite text marked with `lang=`, `font=` and `map=` into the plain span,
- * div and poetry grammar the rest of each chain renders, one line for one line.
+ * div and verse grammar the rest of each chain renders, one line for one line.
  *
+ * - **A verse in columns is expanded first** into one span per column entry
+ *   per verse line, by {@link module:engine/content-verse.expandVerse}, so
+ *   each entry is mapped and set as a span with its keys is. That is the one
+ *   rewrite that changes the number of lines.
  * - **The map, if any, is applied first.** Characters Markdown would read are
  *   then backslash-escaped, so they reach every later pass as characters.
+ * - **Emphasis in a face** becomes an `<em>` or a `<strong>` carrying its
+ *   convention's class, or no class where none is stated. The book reads
+ *   only the classed form, so a classless one writes nothing there.
  * - **The construct carries** the language's tag as `lang`, the face's class
  *   (with `script`, and `script-block` on a div) or the generic family's
  *   class. On the site, a face's construct also carries
@@ -1156,7 +1483,10 @@ function rewrittenAttributes(detail, search) {
  */
 export function renderRuns(source, ctx = {}, syntax, options = {}) {
     const search = options.target === "site";
-    const text = String(source ?? "");
+    const book = options.target === "book";
+    const authored = String(source ?? "");
+    const text = expandVerse(authored);
+    if (text !== authored) syntax = undefined;
     if (!/\b(?:lang|font|map)=/.test(text)) return { markdown: text, errors: [] };
     const { details, errors } = analyseRuns(text, ctx, syntax);
     if (!details.length) return { markdown: text, errors };
@@ -1185,11 +1515,14 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
             const contentEnd = /** @type {number} */ (detail.contentEnd);
             let inner = text.slice(run.start + 1, contentEnd);
             if (detail.plain)
-                inner = setText(
-                    inner,
-                    detail.mapping,
+                inner = setRange(
+                    text,
+                    run.start + 1,
+                    contentEnd,
+                    detail,
                     run.start === 0 || text[run.start - 1] === "\n",
-                ).text;
+                    book,
+                );
             else if (attributes === undefined) continue;
             const braces = attributes ?? text.slice(contentEnd + 2, run.end - 1);
             edits.push({ from: run.start, to: run.end, text: `[${inner}]{${braces}}` });
@@ -1207,7 +1540,7 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
         if (detail.plain && detail.body)
             for (const [from, to] of outsideHoles(detail.body[0], detail.body[1], detail.holes)) {
                 const lineStart = from === 0 || text[from - 1] === "\n";
-                const set = setText(text.slice(from, to), detail.mapping, lineStart).text;
+                const set = setRange(text, from, to, detail, lineStart, book);
                 if (set !== text.slice(from, to)) edits.push({ from, to, text: set });
             }
     }