@heroiclands/package-build 25.0.0 → 25.1.1

package/engine/roman-characters.mjs

@@ -11,7 +11,16 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
-/** A language's exact Roman source characters, before any script conversion. */
+/** A language's Roman additions and the shared punctuation standard. */
+
+import { isSettingScriptCodePoint } from "./content-charset.mjs";
+
+/** Sentence terminals in the shared Roman standard. */
+const TERMINALS = new Set(".?‼!");
+/** Unconditional punctuation; ^ is conditional indentation or a language addition. */
+const STANDARD = new Set(".?‼!,«»‹›—…/{}⟦⟧");
+/** Exactly the encoding definition's word-separating whitespace class. */
+export const isRomanWhitespace = (char) => /^[\p{Zs}\u0009-\u000D]$/u.test(char);
 
 /** Unicode graphemes keep every canonically composing sequence together. */
 const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
@@ -38,6 +47,21 @@ export function romanInventoryProblems(value) {
         );
     if (/[\p{Cc}\p{Cf}\p{Cs}]/u.test(value))
         problems.push("`data.roman` contains a control, format or unpaired surrogate character");
+    const supplied = [...new Set(value)].filter(
+        (char) => STANDARD.has(char) || /[;:"“”]/u.test(char),
+    );
+    if (supplied.length)
+        problems.push(
+            "`data.roman` lists only language additions, without standard punctuation, literal markers, semicolons, colons or English quotation marks: " +
+                supplied.map((char) => `\`${char}\``).join(", "),
+        );
+    const native = [...new Set(value)].filter((char) =>
+        isSettingScriptCodePoint(char.codePointAt(0)),
+    );
+    if (native.length)
+        problems.push(
+            "`data.roman` lists Roman additions, without setting-script characters; write exact native characters through codage",
+        );
     const seen = new Set();
     const repeated = new Set();
     for (const char of value) {
@@ -85,29 +109,124 @@ export function romanInventoriesOf(records, languages = {}) {
  * No punctuation, case or normalization repair is performed.
  * @param {string} text - Visible Roman source.
  * @param {RomanInventory} inventory - Its language's declared characters.
- * @param {(char: string) => boolean} [native] - Whether a directly typed native sign is drawn in the selected native face.
  * @returns {Array<{offset: number, message: string}>}
  */
-export function romanTextProblems(text, inventory, native = () => false) {
+export function romanTextProblems(text, inventory) {
     const out = [];
     if (!inventory.characters) return out;
-    for (const { segment: cluster, index } of graphemes.segment(text)) {
-        let offset = index;
-        if (cluster !== cluster.normalize("NFC")) {
-            out.push({
+    const decomposed = new Map(
+        [...graphemes.segment(text)]
+            .filter(({ segment }) => segment !== segment.normalize("NFC"))
+            .map(({ segment, index }) => [index, segment]),
+    );
+    const quotes = [];
+    let sentenceStart = true;
+    const report = (offset, message) => out.push({ offset, message });
+    for (let offset = 0; offset < text.length;) {
+        const char = String.fromCodePoint(text.codePointAt(offset));
+        if (char === "⟦") {
+            // The encoding validates codage and its boundary grammar. Roman
+            // punctuation and language letters never reinterpret its contents.
+            const close = text.indexOf("⟧", offset + 1);
+            offset = close < 0 ? text.length : close + 1;
+            sentenceStart = false;
+            continue;
+        }
+        const cluster = decomposed.get(offset);
+        if (cluster) {
+            report(
                 offset,
-                message: `\`${cluster}\` is not NFC spelling in \`${inventory.language}\`; write \`${cluster.normalize("NFC")}\``,
-            });
+                `\`${cluster}\` is not NFC spelling in \`${inventory.language}\`; write \`${cluster.normalize("NFC")}\``,
+            );
+            offset += cluster.length;
+            sentenceStart = false;
             continue;
         }
-        for (const char of cluster) {
-            if (!/[ \t\r\n]/u.test(char) && !inventory.characters.has(char) && !native(char))
-                out.push({
-                    offset,
-                    message: `\`${char}\` (${codeName(char)}) is not in \`${inventory.language}\`'s \`data.roman\` inventory`,
-                });
+        if (isRomanWhitespace(char)) {
             offset += char.length;
+            continue;
         }
+        if (char === "^") {
+            const start =
+                Math.max(text.lastIndexOf("\n", offset - 1), text.lastIndexOf("/", offset - 1)) + 1;
+            if (/^\^*$/.test(text.slice(start, offset))) {
+                // Indentation is layout and leaves sentence-start ellipsis
+                // semantics intact. The reference encoder uses these bounds.
+                offset += char.length;
+                continue;
+            }
+        }
+        if (text.startsWith("<<", offset) || text.startsWith(">>", offset)) {
+            report(
+                offset,
+                `write \`${char === "<" ? "«" : "»"}\` for a quotation, not \`${char}${char}\``,
+            );
+            offset += 2;
+            continue;
+        }
+        if (text.startsWith("...", offset)) {
+            report(offset, "write the ellipsis `…`, not three periods `...`");
+            offset += 3;
+            continue;
+        }
+        if (char === ";" || char === ":") {
+            report(
+                offset,
+                `\`${char}\` (${codeName(char)}) is not standard Roman punctuation; write \`,\` for a pause within a sentence or \`.\` between complete sentences`,
+            );
+        } else if (/^["“”]$/u.test(char)) {
+            report(
+                offset,
+                "write `«…»` for an outer quotation and `‹…›` for a quotation inside it",
+            );
+        } else if (isSettingScriptCodePoint(char.codePointAt(0))) {
+            report(
+                offset,
+                `write the setting-script character ${codeName(char)} as \`⟦${codeName(char)}⟧\` or by its encoding's codage name`,
+            );
+        } else if (char === "^" && !inventory.characters.has(char)) {
+            report(
+                offset,
+                "`^` is line-start indentation; elsewhere it must be a declared language addition in `data.roman`",
+            );
+        } else if (!STANDARD.has(char) && !inventory.characters.has(char)) {
+            report(
+                offset,
+                `\`${char}\` (${codeName(char)}) is not in \`${inventory.language}\`'s \`data.roman\` inventory`,
+            );
+        }
+        if (char === "«" || char === "‹") {
+            const expected = quotes.length % 2 === 0 ? "«" : "‹";
+            if (char !== expected)
+                report(offset, `a quotation at this depth opens with \`${expected}\``);
+            quotes.push({ char, offset });
+            sentenceStart = true;
+        } else if (char === "»" || char === "›") {
+            const opening = quotes.at(-1);
+            const expected = opening?.char === "«" ? "»" : "›";
+            if (!opening) report(offset, `quotation closer \`${char}\` has no opening quotation`);
+            else {
+                if (char !== expected)
+                    report(offset, `this quotation closes with \`${expected}\`, not \`${char}\``);
+                quotes.pop();
+                sentenceStart = false;
+            }
+        } else if (char === "—" || (char === "…" && !sentenceStart)) {
+            const rest = text.slice(offset + char.length);
+            if ([...rest].some((next) => !isRomanWhitespace(next)) && !TERMINALS.has(rest[0]))
+                report(
+                    offset,
+                    `\`${char}\` is immediately followed by a terminal (\`.\`, \`?\`, \`‼\` or \`!\`) except at the end of a run`,
+                );
+            sentenceStart = false;
+        } else if (TERMINALS.has(char)) sentenceStart = true;
+        else sentenceStart = false;
+        offset += char.length;
     }
-    return out;
+    for (const opening of quotes)
+        report(
+            opening.offset,
+            `quotation \`${opening.char}\` needs its closing \`${opening.char === "«" ? "»" : "›"}\``,
+        );
+    return out.sort((a, b) => a.offset - b.offset);
 }

package/engine/roman-run.mjs

@@ -0,0 +1,149 @@
+/*
+ * 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
+ */
+
+/**
+ * Project an authored run to logical Roman text while retaining source offsets.
+ * Presentation-only children contribute their text; names contribute standard
+ * braces. The caller decides which children are independent runs and which
+ * ranges are layout or emphasis delimiters.
+ * @module
+ */
+
+/**
+ * @typedef {object} RomanSpan
+ * @property {number} start - Opening bracket offset.
+ * @property {number} end - Offset past the attribute block.
+ * @property {number} contentEnd - Closing bracket offset.
+ * @property {Array<[string, string]>} [attrs] - Authored attributes.
+ */
+
+/**
+ * @typedef {object} ProjectedSpan
+ * @property {RomanSpan} source - The authored child.
+ * @property {number} from - Its first logical UTF-16 offset, including name braces.
+ * @property {number} to - Offset past its logical text and braces.
+ * @property {number} contentFrom - Logical text after its opening name brace.
+ * @property {number} contentTo - Offset past the logical text, before its closing name brace.
+ * @property {boolean} name - Whether this child marks a name.
+ * @property {boolean} included - Whether this child contributes its own text.
+ */
+
+/**
+ * Remove Markdown escapes, inline presentation syntax and excluded layout.
+ * The returned offsets refer to the original source, in UTF-16 units, matching
+ * the source scanner. A supplementary character has two entries, both pointing
+ * at its original first unit. Synthetic braces point at the name's brackets.
+ * @param {string} source - Complete authored source.
+ * @param {object} [options] - Bounds and projections chosen by the run scanner.
+ * @param {number} [options.from] - First included source offset.
+ * @param {number} [options.to] - Offset past the included source.
+ * @param {readonly RomanSpan[]} [options.spans] - Scanned spans, with absolute offsets.
+ * @param {(span: RomanSpan) => boolean} [options.includeSpan] - Whether a child inherits this run.
+ * @param {(span: RomanSpan) => string} [options.opaqueSpan] - Placeholder for an independent child. The default empty name keeps sentence state without introducing that child's letters.
+ * @param {ReadonlyArray<readonly [number, number]>} [options.exclude] - Absolute source ranges that carry layout or presentation syntax.
+ * @param {boolean} [options.markNames] - Whether name children contribute braces.
+ * @returns {{text: string, offsets: number[], spans: ProjectedSpan[]}} Logical text and source locations, with child ranges for presentation.
+ */
+export function plainRomanRun(
+    source,
+    {
+        from = 0,
+        to = source.length,
+        spans = [],
+        includeSpan = () => true,
+        opaqueSpan = () => "{}",
+        exclude = [],
+        markNames = true,
+    } = {},
+) {
+    let text = "";
+    const offsets = [];
+    const projected = [];
+    const children = [...spans]
+        .filter((span) => span.start >= from && span.end <= to)
+        .sort((a, b) => a.start - b.start || b.end - a.end);
+    const byStart = new Map(children.map((span) => [span.start, span]));
+    const excluded = [...exclude].sort((a, b) => a[0] - b[0]);
+    let excludedIndex = 0;
+    const append = (value, offset) => {
+        text += value;
+        for (let unit = 0; unit < value.length; unit++) offsets.push(offset);
+    };
+    const walk = (first, past) => {
+        let at = first;
+        while (at < past) {
+            while (excluded[excludedIndex]?.[1] <= at) excludedIndex++;
+            const omitted = excluded[excludedIndex];
+            if (omitted && omitted[0] <= at) {
+                at = Math.min(past, omitted[1]);
+                continue;
+            }
+            const candidate = byStart.get(at);
+            const span = candidate && candidate.end <= past ? candidate : undefined;
+            if (span) {
+                const name = (span.attrs?.find(([key]) => key === "class")?.[1] ?? "")
+                    .split(/\s+/)
+                    .includes("name");
+                const included = includeSpan(span);
+                const range = {
+                    source: span,
+                    from: text.length,
+                    to: text.length,
+                    contentFrom: text.length,
+                    contentTo: text.length,
+                    name,
+                    included,
+                };
+                projected.push(range);
+                if (included) {
+                    if (name && markNames) append("{", span.start);
+                    range.contentFrom = text.length;
+                    walk(span.start + 1, span.contentEnd);
+                    range.contentTo = text.length;
+                    if (name && markNames) append("}", span.contentEnd);
+                } else {
+                    append(opaqueSpan(span), span.start);
+                    range.contentTo = text.length;
+                }
+                range.to = text.length;
+                at = span.end;
+                continue;
+            }
+            // A codage's notation belongs to its encoding. Do not unescape or
+            // interpret anything between its immutable boundaries.
+            if (source[at] === "⟦") {
+                const close = source.indexOf("⟧", at + 1);
+                const end = close >= 0 && close < past ? close + 1 : past;
+                while (at < end) {
+                    const char = String.fromCodePoint(source.codePointAt(at));
+                    append(char, at);
+                    at += char.length;
+                }
+                continue;
+            }
+            const escaped =
+                source[at] === "\\" && at + 1 < past && /[!-/:-@[-`{-~]/.test(source[at + 1]);
+            const offset = at + (escaped ? 1 : 0);
+            // A terminal Markdown line-break slash is layout, not Roman.
+            if (source[at] === "\\" && !escaped && /[\r\n]/.test(source[at + 1] ?? "")) {
+                at++;
+                continue;
+            }
+            const char = String.fromCodePoint(source.codePointAt(offset));
+            append(char, offset);
+            at = offset + char.length;
+        }
+    };
+    walk(from, to);
+    return { text, offsets, spans: projected };
+}

package/engine/roman-verse.mjs

@@ -0,0 +1,95 @@
+/*
+ * 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
+ */
+
+/** Logical verse text and separately located structural boundaries. @module */
+import { verseLine } from "./content-verse.mjs";
+import { plainRomanRun } from "./roman-run.mjs";
+
+/**
+ * Remove visual indentation before checking or encoding Roman verse. Each
+ * content line keeps its own boundary, including the last line before a stanza
+ * or canto; those extra structural controls do not consume its line boundary.
+ * The caller writes the boundaries through its selected encoding.
+ * @param {string} source - Complete authored source.
+ * @param {Parameters<typeof plainRomanRun>[1] & {isCantoLine?: (line: string) => boolean}} [options] - Run bounds, spans and layout projection.
+ * @returns {ReturnType<typeof plainRomanRun> & {boundaries: Array<{kind: "line"|"stanza"|"canto", at: number, sourceOffset: number}>, errors: Array<{offset: number, message: string}>}} Visible text, positions and structural events.
+ */
+export function plainRomanVerse(source, options = {}) {
+    const {
+        from = 0,
+        to = source.length,
+        exclude = [],
+        isCantoLine = (line) => /^\s*---\s+\{\.canto\}\s*$/.test(line),
+    } = options;
+    const lines = [];
+    const layout = [...exclude];
+    let at = from;
+    for (const match of source.slice(from, to).matchAll(/([^\r\n]*)(\r\n|\r|\n|$)/g)) {
+        if (!match[0]) continue;
+        const line = match[1];
+        const end = at + line.length;
+        const kind =
+            isCantoLine(line) ? "canto"
+            : line.trim() ? "content"
+            : "blank";
+        lines.push({ from: at, to: end, kind });
+        if (kind === "canto") layout.push([at, end]);
+        else if (kind === "content") {
+            const { markerStart, markerLength } = verseLine(line);
+            if (markerLength) layout.push([at + markerStart, at + markerStart + markerLength]);
+        }
+        at += match[0].length;
+    }
+    const projected = plainRomanRun(source, { ...options, from, to, exclude: layout });
+    const logicalAt = (offset) => {
+        let first = 0,
+            past = projected.offsets.length;
+        while (first < past) {
+            const middle = (first + past) >>> 1;
+            if (projected.offsets[middle] < offset) first = middle + 1;
+            else past = middle;
+        }
+        return first;
+    };
+    /** @type {Array<{kind: "line"|"stanza"|"canto", at: number, sourceOffset: number}>} */
+    const boundaries = [];
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (line.kind === "content")
+            boundaries.push({ kind: "line", at: logicalAt(line.to), sourceOffset: line.to });
+        else if (line.kind === "canto")
+            boundaries.push({ kind: "canto", at: logicalAt(line.from), sourceOffset: line.from });
+        else if (lines[index - 1]?.kind === "content") {
+            const following = lines.slice(index + 1).find((next) => next.kind !== "blank");
+            if (following?.kind === "content")
+                boundaries.push({
+                    kind: "stanza",
+                    at: logicalAt(line.from),
+                    sourceOffset: line.from,
+                });
+        }
+    }
+    const errors = [];
+    for (let index = 0; index < projected.text.length; index++) {
+        if (projected.text[index] === "⟦") {
+            const close = projected.text.indexOf("⟧", index + 1);
+            index = close < 0 ? projected.text.length : close;
+        } else if (projected.text[index] === "/")
+            errors.push({
+                offset: projected.offsets[index],
+                message:
+                    "a verse fence uses authored line endings for verse boundaries; write no literal `/` inside it",
+            });
+    }
+    return { ...projected, boundaries, errors };
+}

package/engine/run-rows.mjs

@@ -12,15 +12,14 @@
  */
 
 /**
- * Spans, divs and verse fences marked with `lang=`, `font=` or `map=`, projected
+ * Spans, divs and verse fences 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.
  *
- * Native runs retain their explicit opt-in so language defaults can be filled
- * by {@link fillWrittenIn} once every record exists. Roman language-only runs
- * retain null map/font fields; ordinary generic-family inheritance is already
- * projected by the shared scanner.
+ * Encoding-document language and font defaults are filled by
+ * {@link fillEncodingRuns} once every document exists. Roman runs use the
+ * default encoding; ordinary font inheritance is projected by the scanner.
  *
  * @module
  */
@@ -29,9 +28,8 @@ import { canonicalKey, readCanonicalKey } from "./address.mjs";
 import { encodeAddresses } from "./address-values.mjs";
 import { isNoteRecord } from "./index-records.mjs";
 import { scanRuns } from "./content-scripts.mjs";
-import { languageRecordsByName } from "./map-lexicon.mjs";
-import { mapsFromRecords } from "./text-maps.mjs";
-import { writtenInOf } from "./written-in.mjs";
+import { resolveScriptFonts } from "./script-fonts.mjs";
+import { encodingsFromRecords, encodingAddress } from "./encoding-notes.mjs";
 
 /** Every column of the `runs` relation, in order. */
 export const RUN_COLUMNS = Object.freeze([
@@ -40,7 +38,7 @@ export const RUN_COLUMNS = Object.freeze([
     "lang",
     "tag",
     "font",
-    "map",
+    "enc",
     "line",
     "column",
 ]);
@@ -54,11 +52,8 @@ export const RUN_COLUMNS = Object.freeze([
  *   own `lang=`, else the one the div or fence around it states.
  * @property {string|null} tag - The BCP 47 tag it resolves to, or null.
  * @property {string|null} font - Its explicit font, an inherited ordinary
- *   prose family, or the configured default for an opted-in native run.
- * @property {string|null} map - Its explicit map or the configured map of an
- *   opted-in native run; null for Roman language-only text.
- * @property {boolean} [nativefont] - Explicit native opt-in on this construct;
- *   absent on Roman runs. This internal flag is not a SQL column.
+ *   prose family, or the font of the selected encoding document.
+ * @property {string|null} enc - Its resolved encoding document, or default for Roman text.
  * @property {number} line - 1-based file line of its opening.
  * @property {number} column - 1-based UTF-16 file column of its opening.
  */
@@ -86,36 +81,39 @@ export function recordRuns(body, { context, bodyLine = 1, bodyColumn = 1, syntax
         lang: run.lang ?? null,
         tag: run.tag ?? null,
         font: run.font ?? null,
-        map: run.map ?? null,
-        ...(run.nativefont ? { nativefont: true } : {}),
+        enc: run.enc ?? null,
         line: bodyLine + run.line - 1,
         column: run.column + (run.line === 1 ? bodyColumn - 1 : 0),
     }));
 }
 
 /**
- * Give explicitly native recorded runs the map and face their language names in
- * `data.writtenIn`, where the run leaves them unstated, as a run is set. Read
- * once every record exists, since a run's language note may be recorded after
- * the note that marks it.
+ * Resolve recorded encoding Addresses and fill the language and font supplied
+ * by each selected document, once every index record exists.
  *
  * @param {Record<string, any>[]} records - The package's index records; each
  *   note record's `runs` is updated in place.
- * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string, rootDir?:string, paths?:{content?:string}}} config -
  *   The configured languages, whose `note` names each language note.
  */
-export function fillWrittenIn(records, config) {
-    const maps = mapsFromRecords(records);
-    const scripts = writtenInOf(languageRecordsByName(records, config), maps);
-    if (!scripts.size) return;
+export function fillEncodingRuns(records, config) {
+    const { encodings } = encodingsFromRecords(
+        records,
+        config,
+        config?.rootDir ? resolveScriptFonts(config.rootDir) : undefined,
+    );
     for (const record of records) {
         if (!record || !isNoteRecord(record) || !Array.isArray(record.runs)) continue;
         for (const run of record.runs) {
-            if (!run.nativefont) continue;
-            const script = scripts.get(run.lang);
-            if (!script) continue;
-            if (run.map == null) run.map = script.map;
-            if (run.font == null) run.font = script.font;
+            run.enc ??= "default";
+            const encoding =
+                encodings.get(run.enc) ??
+                encodings.get(encodingAddress(run.enc, config.contentPackage));
+            if (!encoding) continue;
+            run.enc = encoding.name;
+            run.lang ??= encoding.language;
+            run.font ??= encoding.font;
+            run.tag ??= config.languages?.[run.lang]?.tag ?? null;
         }
     }
 }
@@ -150,7 +148,7 @@ export function runsRows(records) {
                 lang: run.lang ?? null,
                 tag: run.tag ?? null,
                 font: run.font ?? null,
-                map: run.map ?? null,
+                enc: run.enc ?? null,
                 line: run.line,
                 column: run.column,
             });

package/engine/run-words.mjs

@@ -13,7 +13,7 @@
 
 /**
  * **A mapped run's words are words of its language.** In a run marked with
- * `lang=`, whose language's `note` names its language note, and with `map=`,
+ * `lang=`, whose language's `note` names its language note, and with `enc=`,
  * each word (see {@link module:engine/word-pattern.WORD}) is accepted when,
  * case folded, it is:
  *
@@ -36,7 +36,7 @@
  * @module
  */
 
-import { lexiconsFromRecords } from "./map-lexicon.mjs";
+import { lexiconsFromRecords } from "./encoding-lexicon.mjs";
 import { RESERVED_TONGUE } from "./language-terms.mjs";
 import { addWords, foldWord, lexiconWords } from "./word-forms.mjs";
 import { WORD } from "./word-pattern.mjs";

package/engine/script-emphasis-terms.mjs

@@ -44,3 +44,6 @@ export const SCRIPT_DIRECTIONS = Object.freeze(["vertical-rl"]);
 
 /** The `subType` of a script note. */
 export const SCRIPT_SUBTYPE = "script";
+
+/** The ordinary prose families accepted by font=. */
+export const GENERIC_FAMILIES = Object.freeze(["mono", "serif", "sans"]);

package/engine/script-emphasis.mjs

@@ -21,14 +21,12 @@
  *   script:
  *     fonts: [semaron-kuriale]
  *     emphasis: rubric
- *     strongEmphasis: overline
  * ```
  *
  * - **`fonts`** lists installed faces by the slug `font=` names them by. A
  *   face belongs to one script.
  * - **`emphasis`** is `rubric` (red text) or `overline` (a line above the
  *   word), and sets both `*…*` and `**…**`.
- * - **`strongEmphasis`**, where stated, sets `**…**` alone.
  *
  * Inside a run in one of those faces, `*…*` and `**…**` stay an `<em>` and a
  * `<strong>` on the site and in Foundry, carrying {@link module:engine/script-emphasis-terms.EMPHASIS_CLASSES}'s
@@ -48,7 +46,7 @@ import {
     LANGUAGE_EMPHASES,
     SCRIPT_SUBTYPE,
 } from "./script-emphasis-terms.mjs";
-import { GENERIC_FAMILIES } from "./text-maps.mjs";
+import { GENERIC_FAMILIES } from "./script-emphasis-terms.mjs";
 import { LANGUAGE_SUBTYPE } from "./word-terms.mjs";
 
 export {
@@ -97,12 +95,7 @@ export function emphasesFromRecords(records) {
         const script = record.data?.script;
         if (!isMap(script) || !Array.isArray(script.fonts) || !isConvention(script.emphasis))
             continue;
-        const strong =
-            script.strongEmphasis === undefined || script.strongEmphasis === null ?
-                script.emphasis
-            :   script.strongEmphasis;
-        if (!isConvention(strong)) continue;
-        const emphasis = Object.freeze({ em: script.emphasis, strong });
+        const emphasis = Object.freeze({ em: script.emphasis, strong: script.emphasis });
         for (const slug of script.fonts)
             if (typeof slug === "string" && !out.has(slug)) out.set(slug, emphasis);
     }
@@ -114,7 +107,7 @@ export function emphasesFromRecords(records) {
  *
  * @param {ReadonlyMap<string, Record<string, any>>} byName - Each configured
  *   language's note record, by language name, from
- *   {@link module:engine/map-lexicon.languageRecordsByName}.
+ *   {@link module:engine/encoding-lexicon.languageRecordsByName}.
  * @returns {Map<string, LanguageEmphasis>} The conventions, by language name;
  *   a language whose note states none, or one the build does not know, is
  *   absent.