@heroiclands/package-build 25.1.1 → 25.1.3

package/engine/content-alerts.mjs

@@ -12,6 +12,7 @@
  */
 
 import MarkdownIt from "markdown-it";
+import { blockTokens } from "./markdown-blocks.mjs";
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
 import { slugify } from "./content-slug.mjs";
 
@@ -48,7 +49,6 @@ export const ALERT_TYPES = Object.freeze({
         ),
     },
 });
-const parser = new MarkdownIt({ html: true });
 const titleParser = new MarkdownIt({ html: false });
 const marker = /^ {0,3}>[ \t]?\[!([^\]\n]+)\](.*)$/;
 /** Read alerts outside code examples, retaining inclusive source line ranges.
@@ -60,7 +60,7 @@ export function scanAlerts(source) {
         blocks = [],
         errors = [];
     let depth = 0;
-    for (const token of parser.parse(text, {})) {
+    for (const token of blockTokens(text)) {
         if (token.type === "blockquote_close") {
             depth--;
             continue;

package/engine/content-blocks.mjs

@@ -52,6 +52,7 @@
 import crypto from "node:crypto";
 import { slugify } from "./content-slug.mjs";
 import MarkdownIt from "markdown-it";
+import { blockTokens } from "./markdown-blocks.mjs";
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
 import { scanVerse, renderVerse } from "./content-verse.mjs";
 import { renderScroll, scanScrolls } from "./content-scroll.mjs";
@@ -63,7 +64,6 @@ import { WITHHELD_CLASS, parseHeadingLine, withheldSections } from "./heading-at
  * and a stray `<section>` would close the block early.
  */
 const titleParser = new MarkdownIt({ html: false });
-const structureParser = new MarkdownIt({ html: true });
 
 /** The blocks an author may open, with the heading each takes by default. */
 export const BLOCK_NAMES = Object.freeze({
@@ -108,7 +108,7 @@ export function scanBlocks(source) {
     // A bare fence can belong to a quote through lazy continuation.
     // Parser ranges decide whether it can delimit a container.
     const literalLines = new Set();
-    for (const token of structureParser.parse(String(source ?? ""), {})) {
+    for (const token of blockTokens(source)) {
         if (
             !token.map ||
             !["blockquote_open", "fence", "code_block", "html_block"].includes(token.type)

package/engine/content-index.mjs

@@ -1087,6 +1087,8 @@ export function resolveCultures(
  * @param {Map<string, {raw: string}>} [options.sources] - Selected captured source strings.
  * @param {import("./content-session.mjs").ContentSyntax} [options.syntax] - Session scanner projections.
  * @param {Iterable<string>} [options.nameTypes] - Additional bare name kinds from configured type declarations.
+ * @param {ReturnType<typeof import("./content-timings.mjs").createContentTimings>} [options.timings] -
+ *   Invocation stage accounting, which records each phase of the derivation.
  * @returns {Array<Record<string, any>>} The records, in a total order that does
  *   not depend on directory-read order.
  */
@@ -1109,8 +1111,16 @@ export function collectContentIndex(
         sources,
         syntax,
         nameTypes,
+        timings,
     },
 ) {
+    // Each phase runs until the next begins; the caller's stage closes the last.
+    let phaseEnd;
+    const phase = (name) => {
+        phaseEnd?.();
+        phaseEnd = timings?.start(name);
+    };
+    phase("index read");
     const records = [];
     // Passed through rather than defaulted away: an absent scope is the
     // caller's omission, and `walkMarkdownTree` says so.
@@ -1175,6 +1185,7 @@ export function collectContentIndex(
     );
 
     // Each recorded note with its body, for the words its prose cites.
+    phase("index notes");
     const bodies = [];
     for (const { frontmatter, body, bodyLine, bodyColumn, raw, absPath } of parsedNotes) {
         // Before the index derives anything onto the frontmatter, so a later
@@ -1251,16 +1262,19 @@ export function collectContentIndex(
 
     // The words each note's prose cites, read once every language's words
     // are recorded; the index keeps the citing Addresses and no text.
+    phase("index citations");
     attachCitations(records, bodies);
 
     // A run marked with a language alone takes its language's script, which
     // is read once every language note is recorded.
+    phase("index encoding runs");
     fillEncodingRuns(records, { languages, contentPackage, rootDir });
 
     // Every note record exists and every Address in it is a tuple, so a parent
     // is found by its canonical address. Before the sort, which reads nothing
     // the pass writes. Calendars first: they read the culture a note states,
     // which the culture pass then replaces with the one it resolves.
+    phase("index calendars and cultures");
     resolveNoteCalendars(records, {
         contentPackage,
         defaultCalendar,
@@ -1298,6 +1312,7 @@ export function collectContentIndex(
     // projection as the surfaces, without making the index emitter async.
     // Public notes resolve providers in their audience, including lineage
     // through hidden languages, just as their build does.
+    phase("index lexical sections");
     const visible = records.filter((record) => !isGmNote(record));
     const publicSections = lexicalSectionsFor(visible, records);
     const allSections = lexicalSectionsFor(records);
@@ -1319,6 +1334,7 @@ export function collectContentIndex(
     // about the content, and the artifact is meant to be byte-identical across
     // two runs over an unchanged tree. Collected above, ahead of the notes —
     // see `resolveRole` — rather than walked a second time here.
+    phase("index order");
     for (const record of assetRecords) {
         records.push(/** @type {Record<string, any>} */ (sortKeysDeep(record)));
     }
@@ -1344,9 +1360,11 @@ export function collectContentIndex(
             ) ||
             String(a.id ?? "").localeCompare(String(b.id ?? ""), "en"),
     );
-    return records.map((record) =>
+    const decoded = records.map((record) =>
         decodeIndexAddresses(record, addressContext ?? { package: contentPackage }),
     );
+    phaseEnd?.();
+    return decoded;
 }
 
 /**
@@ -1465,6 +1483,8 @@ function dependencyAddresses(config) {
  * @param {import("./content-session.mjs").ContentSyntax} [opts.syntax] - Session scanner projections.
  * @param {Iterable<string>} [opts.nameTypes] - Bare name kinds, defaulting to configured item types.
  * @param {Map<string, object>} [opts.foreignIndex] - Captured dependency address view.
+ * @param {ReturnType<typeof import("./content-timings.mjs").createContentTimings>} [opts.timings] -
+ *   Invocation stage accounting.
  * @returns {object[]} One record per note, plus one per documentation entry.
  */
 export function indexRecordsFor({
@@ -1478,6 +1498,7 @@ export function indexRecordsFor({
     syntax,
     nameTypes,
     foreignIndex,
+    timings,
 } = {}) {
     const resolved = config ?? loadPackConfig();
     const tree = contentBase ?? resolved.paths.content;
@@ -1512,6 +1533,7 @@ export function indexRecordsFor({
         sources,
         syntax,
         nameTypes: nameTypes ?? resolved.itemTypes,
+        timings,
     });
 }
 

package/engine/content-scripts.mjs

@@ -41,6 +41,7 @@
  */
 
 import MarkdownIt from "markdown-it";
+import { blockTokens } from "./markdown-blocks.mjs";
 
 import { scanBlocks, BLOCK_CONTAINERS } from "./content-blocks.mjs";
 import { scanVerse, hasColumns, verseLine, verseGroups, STANZA_BREAK } from "./content-verse.mjs";
@@ -737,9 +738,6 @@ function codeName(point) {
     return `U+${point.toString(16).toUpperCase().padStart(4, "0")}`;
 }
 
-/** A parser for the block structure of a div's body. */
-const blockParser = new MarkdownIt({ html: true });
-
 /** What a block token is called in a finding. */
 const BLOCK_WHAT = Object.freeze({
     heading_open: "a heading",
@@ -1485,7 +1483,7 @@ function analyseRuns(source, ctx, syntax) {
                     { line: first + line + 1, column: /^ */.exec(body[line])[0].length + 1 },
                     `a div marked \`${marking}\` holds paragraphs and line breaks only, not ${what}`,
                 );
-            for (const token of blockParser.parse(body.join("\n"), {})) {
+            for (const token of blockTokens(body.join("\n"))) {
                 if (token.level !== 0 || !token.map) continue;
                 const [top, past] = token.map;
                 if (token.type === "paragraph_open") {
@@ -1535,7 +1533,14 @@ function analyseRuns(source, ctx, syntax) {
     const boundsOf = (detail) =>
         detail.reference ??
         (detail.run.kind === "span" ? [detail.run.start + 1, detail.contentEnd] : detail.body);
+    // Each run's parent and owner are read many times while ownership is
+    // assigned below, so each is found once.
+    const parents = new Map();
     const parentOf = (detail) => {
+        if (!parents.has(detail)) parents.set(detail, findParent(detail));
+        return parents.get(detail);
+    };
+    const findParent = (detail) => {
         if (detail.run.kind !== "span" || Object.keys(detail.keys).length) return undefined;
         return details
             .filter(
@@ -1547,9 +1552,13 @@ function analyseRuns(source, ctx, syntax) {
             )
             .sort((a, b) => boundsOf(a)[1] - boundsOf(a)[0] - (boundsOf(b)[1] - boundsOf(b)[0]))[0];
     };
+    const owners = new Map();
     const ownerOf = (detail) => {
-        const parent = parentOf(detail);
-        return parent ? ownerOf(parent) : detail;
+        if (!owners.has(detail)) {
+            const parent = parentOf(detail);
+            owners.set(detail, parent ? ownerOf(parent) : detail);
+        }
+        return owners.get(detail);
     };
     const wholeVerseReading = (detail) => {
         if (detail.run.kind === "verse") return true;

package/engine/content-scroll.mjs

@@ -42,7 +42,7 @@
  * @module
  */
 
-import MarkdownIt from "markdown-it";
+import { blockTokens } from "./markdown-blocks.mjs";
 
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
 
@@ -78,8 +78,6 @@ export const BOOK_SCROLL_ROWS = 40;
 /** The class every scroll carries. */
 export const SCROLL_CLASS = "scroll";
 
-const structureParser = new MarkdownIt({ html: true });
-
 /**
  * One `scroll` fence.
  *
@@ -129,7 +127,7 @@ export function scanScrolls(source) {
     if (!/^ *(?:`{3,}|~{3,}) *scroll(?:\s|$)/m.test(text)) return { blocks, errors };
     const lines = text.split("\n");
     const literalLines = new Set();
-    for (const token of structureParser.parse(text, {})) {
+    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-session.mjs

@@ -144,6 +144,7 @@ export async function createContentSession({
             problems,
             foreignIndex: foreign.index,
             syntax,
+            timings,
         }),
     );
     const memo = (key, make) => {

package/engine/content-timings.mjs

@@ -24,12 +24,15 @@ export function createContentTimings() {
         stages.set(name, (stages.get(name) ?? 0) + now - changed);
         changed = now;
     };
+    // Ending a stage also ends any stage opened inside it and left open.
     const begin = (name) => {
         account();
+        const depth = stack.length;
         stack.push(name);
         return () => {
+            if (stack.length <= depth) return;
             account();
-            stack.pop();
+            stack.length = depth;
         };
     };
     return {
@@ -51,6 +54,15 @@ export function createContentTimings() {
                 stop();
             }
         },
+        /**
+         * Open a stage that runs until the returned function is called, or
+         * until the stage it was opened in ends.
+         * @param {string} name
+         * @returns {() => void}
+         */
+        start(name) {
+            return begin(name);
+        },
         /** @param {string} name */
         hit(name) {
             hits.set(name, (hits.get(name) ?? 0) + 1);

package/engine/content-verse.mjs

@@ -180,11 +180,11 @@ function columnsMarkdown(block, lines, step) {
 }
 
 import MarkdownIt from "markdown-it";
+import { blockTokens } from "./markdown-blocks.mjs";
 import { slugify } from "./content-slug.mjs";
 import { spanMarkdownPlugin } from "./content-spans.mjs";
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
 
-const structureParser = new MarkdownIt({ html: true });
 const lineParser = new MarkdownIt({ html: true }).use(spanMarkdownPlugin);
 
 /** The structural first span of a line, with its source ranges and keys. */
@@ -223,7 +223,7 @@ export function scanVerse(source) {
         blocks = [],
         errors = [];
     const literalLines = new Set();
-    for (const token of structureParser.parse(String(source ?? ""), {})) {
+    for (const token of blockTokens(source)) {
         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/dictionary-rows.mjs

@@ -464,6 +464,16 @@ export function dictionaryAndTermRows(records, all = records) {
         );
         return hit ? hit.entry[key] : undefined;
     };
+    // One piece lookup per language, shared by every word that language states.
+    const glossers = new Map();
+    const glossesFor = (language) => {
+        if (!glossers.has(language))
+            glossers.set(
+                language,
+                pieceGlosses(...lineage(language).map((key) => languages.get(key).data)),
+            );
+        return glossers.get(language);
+    };
     const etymologyOf = ({ word, statedIn, depth }) => {
         const blank = Object.fromEntries(ETYMOLOGY_KEYS.map((key) => [key, null]));
         if (depth > 0)
@@ -476,13 +486,15 @@ export function dictionaryAndTermRows(records, all = records) {
             };
         const source = isMap(word.source) ? word.source : {};
         const built = Array.isArray(word.built) ? word.built.map(String) : [];
-        const glossOf = pieceGlosses(...lineage(statedIn).map((key) => languages.get(key).data));
         const out = {
             ...blank,
             kind: typeof source.kind === "string" ? source.kind : null,
             language: typeof source.language === "string" ? source.language : null,
             form: typeof source.form === "string" ? source.form : null,
-            parts: built.length ? built.map((form) => ({ form, gloss: glossOf(form) })) : null,
+            parts:
+                built.length ?
+                    built.map((form) => ({ form, gloss: glossesFor(statedIn)(form) }))
+                :   null,
             root: typeof word.root === "string" ? word.root : null,
             frame: typeof word.frame === "string" ? word.frame : null,
         };

package/engine/encoding-language.mjs

@@ -69,7 +69,14 @@ function capitalWriting(enc, word, native, font) {
             upper.to + native.slice(lower.to.length)
         :   undefined;
 }
+/** Each lexicon's forms, found once; a lexicon is not modified once it is converted with. */
+const formsOf = new WeakMap();
 function entryForms(lexicon) {
+    if (!lexicon) return findEntryForms(lexicon);
+    if (!formsOf.has(lexicon)) formsOf.set(lexicon, findEntryForms(lexicon));
+    return formsOf.get(lexicon);
+}
+function findEntryForms(lexicon) {
     const data = lexicon?.data ?? {};
     const derived = new Map();
     for (const entry of derivedForms(data)) {
@@ -122,6 +129,44 @@ function entryForms(lexicon) {
     ];
 }
 
+/** Each lexicon's phrases of more than one word, with the patterns that find them. */
+const phrasesFound = new WeakMap();
+function phrasesOf(lexicon) {
+    if (!phrasesFound.has(lexicon))
+        phrasesFound.set(
+            lexicon,
+            entryForms(lexicon)
+                .map((entry) => entry.form)
+                .filter((form) => [...form.matchAll(WORD)].length > 1)
+                .map((form) => ({
+                    form,
+                    spaces: form.match(/[\p{Zs}\u0009-\u000D]+/gu) ?? [],
+                    pattern: new RegExp(
+                        form
+                            .split(/[\p{Zs}\u0009-\u000D]+/u)
+                            .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+                            .join("[\\p{Zs}\\u0009-\\u000D]+"),
+                        "iuy",
+                    ),
+                })),
+        );
+    return phrasesFound.get(lexicon);
+}
+
+/** Each lexicon's words' forms and variants, as written. */
+const statedFound = new WeakMap();
+function statedForms(lexicon) {
+    if (!statedFound.has(lexicon)) {
+        const forms = new Set();
+        for (const entry of list(lexicon.data.words)) {
+            forms.add(entry.form);
+            for (const variant of list(entry.variants)) forms.add(variant);
+        }
+        statedFound.set(lexicon, forms);
+    }
+    return statedFound.get(lexicon);
+}
+
 function literalEnd(text, at) {
     let cursor = at + OPEN.length;
     while (cursor < text.length) {
@@ -164,23 +209,7 @@ export function encodeWithLanguage(enc, text, options = {}) {
     }
     const writing =
         options.lexicon ? writingsOf(options.lexicon.data, enc.name, options.font) : undefined;
-    const phrases =
-        options.lexicon ?
-            entryForms(options.lexicon)
-                .map((entry) => entry.form)
-                .filter((form) => [...form.matchAll(WORD)].length > 1)
-                .map((form) => ({
-                    form,
-                    spaces: form.match(/[\p{Zs}\u0009-\u000D]+/gu) ?? [],
-                    pattern: new RegExp(
-                        form
-                            .split(/[\p{Zs}\u0009-\u000D]+/u)
-                            .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
-                            .join("[\\p{Zs}\\u0009-\\u000D]+"),
-                        "iuy",
-                    ),
-                }))
-        :   [];
+    const phrases = options.lexicon ? phrasesOf(options.lexicon) : [];
     let at = 0;
     const appendRows = (from, to) => {
         let cursor = from;
@@ -267,9 +296,7 @@ export function encodeWithLanguage(enc, text, options = {}) {
         } else if (own && "text" in own) {
             appendRows(at, start);
             let native = own.text;
-            const exact = list(options.lexicon.data.words).some(
-                (entry) => entry.form === lookup || list(entry.variants).includes(lookup),
-            );
+            const exact = statedForms(options.lexicon).has(lookup);
             if (!exact && match[0] !== match[0].toLowerCase()) {
                 const capital =
                     match[0] === initialCapital(match[0].toLowerCase()) ?

package/engine/encoding-lexicon.mjs

@@ -22,6 +22,7 @@ import { isLanguageRecord, lineageChain, noteAddressOf } from "./word-rows.mjs";
 import { derivedForms, foldWord } from "./word-forms.mjs";
 import { WRITTEN_ENDINGS, RESERVED_TONGUE } from "./language-terms.mjs";
 import { LANGUAGE_SUBTYPE, glossText } from "./word-terms.mjs";
+import { ENGLISH_GROUP } from "./language-names.mjs";
 import { writingsOf } from "./language-writings.mjs";
 import { encodeText, validateSource, EncodingError } from "./encoding.mjs";
 import { encodeWithLanguage } from "./encoding-language.mjs";
@@ -389,9 +390,21 @@ export function nativeRows(records) {
     return rows;
 }
 
-/** Project only conversion-readable language data to a JSON-safe object. */
+/** Each lexicon's projection, made once and shared by every conversion that reads it. */
+const serialized = new WeakMap();
+
+/**
+ * Project only conversion-readable language data to a JSON-safe object. The
+ * projection of one lexicon is made once and shared, so it must not be modified.
+ */
 export function serializeLexicon(lexicon) {
     if (!lexicon) return undefined;
+    if (!serialized.has(lexicon)) serialized.set(lexicon, projectLexicon(lexicon));
+    return serialized.get(lexicon);
+}
+
+/** The conversion-readable data of a lexicon, copied. */
+function projectLexicon(lexicon) {
     const select = (value, keys) =>
         Object.fromEntries(
             keys
@@ -630,7 +643,10 @@ export function checkEncodingLexicon(note, ctx) {
         ...new Map(
             [...(ctx.encodings?.values() ?? [])].map((encoding) => [encoding.name, encoding]),
         ).values(),
-    ].filter((encoding) => aliases.has(encoding.language));
+    ]
+        .filter((encoding) => aliases.has(encoding.language))
+        // A codes-only script accepts no letter, so the roman forms are not written in it.
+        .filter((encoding) => [...encoding.accepted].some((char) => /\p{L}/u.test(char)));
     if (!encodings.length) return [];
     const forms = [],
         data = note.fm.data ?? {};
@@ -641,6 +657,7 @@ export function checkEncodingLexicon(note, ctx) {
         add(word?.form, ["words", i, "form"]);
         listOf(word?.variants).forEach((form, j) => add(form, ["words", i, "variants", j]));
     });
+    // `en` holds English names, which no encoding of the tongue sees.
     const names = (value, keys) => {
         if (Array.isArray(value))
             value.forEach((item, i) =>
@@ -648,7 +665,12 @@ export function checkEncodingLexicon(note, ctx) {
             );
         else if (isMap(value))
             for (const [key, item] of Object.entries(value))
-                if (key !== "pattern" && key !== "metadata") names(item, [...keys, key]);
+                if (
+                    key !== "pattern" &&
+                    key !== "metadata" &&
+                    !(keys.length === 1 && key === ENGLISH_GROUP)
+                )
+                    names(item, [...keys, key]);
     };
     names(data.names, ["names"]);
     listOf(data.elements).forEach((element, i) => {

package/engine/heading-attributes.mjs

@@ -34,15 +34,12 @@
  */
 
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
-import MarkdownIt from "markdown-it";
-
-/** Literal block ranges use the renderer's Markdown grammar. */
-const structureParser = new MarkdownIt({ html: true });
+import { blockTokens } from "./markdown-blocks.mjs";
 
 /** Body lines occupied by code or raw HTML, including comment examples. */
 function literalHeadingLines(source) {
     const lines = new Set();
-    for (const token of structureParser.parse(String(source ?? ""), {})) {
+    for (const token of blockTokens(source)) {
         if (!token.map || !["fence", "code_block", "html_block"].includes(token.type)) continue;
         for (let line = token.map[0]; line < token.map[1]; line++) lines.add(line);
     }

package/engine/language-names.mjs

@@ -33,6 +33,10 @@
  *   person's gender's list, or from every given list together where that gender
  *   has none; `{given.<gender>}` draws from that gender's list whatever the
  *   person's gender, as a patronymic draws a father's name.
+ * - `en` — English names, in groups of lists: `en.epithet` is a list a pattern
+ *   draws from as `{en.epithet}`, as `"{given} the {en.epithet}"` does. English
+ *   names are never encoded in the tongue's script or checked against its
+ *   spelling.
  * - every other key — a list of names the pattern draws from by that key:
  *   `clan`, `family`, `place`. A list name is letters, digits and underscores,
  *   beginning with a letter.
@@ -55,13 +59,16 @@ import { nearest } from "./near-miss.mjs";
 /** The `skill` subType whose notes may carry name lists. */
 export const NAMES_SUBTYPE = "language";
 
+/** The key whose groups of lists hold English names. */
+export const ENGLISH_GROUP = "en";
+
 /** The placeholder that draws from the given-name list for a gender. */
 export const GIVEN_LIST = "given";
 
 /** What a list name may be spelled with. */
 const LIST_NAME = /^[A-Za-z][A-Za-z0-9_]*$/;
 
-/** A placeholder's text: a list name, and for `given` an optional gender. */
+/** A placeholder's text: a list name, and after a dot a gender for `given` or a list for `en`. */
 const PLACEHOLDER = /^([A-Za-z][A-Za-z0-9_]*)(?:\.([A-Za-z][A-Za-z0-9_]*))?$/;
 
 /**
@@ -80,11 +87,12 @@ export function requiredGivenGenders() {
  * One piece of a parsed pattern: literal text, or a placeholder naming a list
  * and, for `given`, the gender whose list it draws from.
  *
- * @typedef {{literal: string} | {list: string, gender?: string}} PatternPart
+ * @typedef {{literal: string} | {list: string, gender?: string, sub?: string}} PatternPart
  */
 
 /** A placeholder as written, without its braces. */
 function placeholderText(part) {
+    if (part.sub !== undefined) return `${part.list}.${part.sub}`;
     return part.gender ? `${part.list}.${part.gender}` : part.list;
 }
 
@@ -126,17 +134,22 @@ export function parsePattern(pattern) {
                 `has the placeholder \`{${text}}\`; a placeholder names a list in letters, ` +
                     "digits and underscores, beginning with a letter",
             );
-        else if (match[2] !== undefined && match[1] !== GIVEN_LIST)
+        else if (match[1] === ENGLISH_GROUP && match[2] === undefined)
+            problems.push(
+                `has the placeholder \`{${text}}\`; \`en\` holds groups of English names, ` +
+                    "so a placeholder names one as `{en.<list>}`",
+            );
+        else if (match[2] !== undefined && match[1] !== GIVEN_LIST && match[1] !== ENGLISH_GROUP)
             problems.push(
                 `has the placeholder \`{${text}}\`; only \`given\` takes a gender after a dot, ` +
-                    "as `{given.male}` does",
+                    "as `{given.male}` does, and `en` a list, as `{en.epithet}` does",
             );
         else {
             if (literal) parts.push({ literal });
             literal = "";
-            parts.push(
-                match[2] === undefined ? { list: match[1] } : { list: match[1], gender: match[2] },
-            );
+            if (match[2] === undefined) parts.push({ list: match[1] });
+            else if (match[1] === ENGLISH_GROUP) parts.push({ list: match[1], sub: match[2] });
+            else parts.push({ list: match[1], gender: match[2] });
         }
         i = close + 1;
     }
@@ -263,7 +276,30 @@ export function namesProblems(names, lookVocabulary) {
         });
     };
 
-    const lists = Object.keys(names).filter((key) => key !== "pattern");
+    const lists = Object.keys(names).filter((key) => key !== "pattern" && key !== ENGLISH_GROUP);
+    const english = names[ENGLISH_GROUP];
+    const englishLists = [];
+    if (english !== undefined && english !== null) {
+        if (!isPlainMap(english))
+            shape(
+                [ENGLISH_GROUP],
+                `\`${label([ENGLISH_GROUP])}\` should be a map of names to lists of English names`,
+            );
+        else
+            for (const key of Object.keys(english)) {
+                if (!LIST_NAME.test(key)) {
+                    problem(
+                        [ENGLISH_GROUP, key],
+                        `"${key}" is not a list name; a list of \`${label([ENGLISH_GROUP])}\` is ` +
+                            "named in letters, digits and underscores, beginning with a letter",
+                        true,
+                    );
+                    continue;
+                }
+                englishLists.push(key);
+                checkList([ENGLISH_GROUP, key]);
+            }
+    }
     for (const key of lists) {
         if (key === GIVEN_LIST) continue;
         if (!LIST_NAME.test(key)) {
@@ -376,6 +412,19 @@ export function namesProblems(names, lookVocabulary) {
         if (parsed.problems.length) unreadable = true;
         for (const part of parsed.parts) {
             if (!("list" in part)) continue;
+            if (part.sub !== undefined) {
+                named.add(placeholderText(part));
+                if (englishLists.includes(part.sub)) continue;
+                const guess = nearest(part.sub, englishLists);
+                problem(
+                    path,
+                    `\`{${placeholderText(part)}}\` in \`${label(path)}\` names no list of ` +
+                        `\`${label([ENGLISH_GROUP])}\`` +
+                        (englishLists.length ? `; the lists are ${englishLists.join(", ")}` : "") +
+                        (guess ? `. Did you mean "{en.${guess}}"?` : ""),
+                );
+                continue;
+            }
             named.add(part.list);
             if (part.gender !== undefined) {
                 if (givenMap[part.gender] === undefined || givenMap[part.gender] === null)
@@ -397,6 +446,15 @@ export function namesProblems(names, lookVocabulary) {
         }
     }
     if (unreadable) return problems;
+    for (const list of englishLists) {
+        if (named.has(`${ENGLISH_GROUP}.${list}`)) continue;
+        problem(
+            [ENGLISH_GROUP, list],
+            `\`${label([ENGLISH_GROUP, list])}\` is never drawn from: no pattern of ` +
+                `\`${label(["pattern"])}\` has \`{${ENGLISH_GROUP}.${list}}\``,
+            true,
+        );
+    }
     for (const list of lists) {
         if (named.has(list)) continue;
         problem(
@@ -490,6 +548,7 @@ export function givenNames(names, gender) {
 
 /** The names one placeholder draws from, for a person of `gender`. */
 function listFor(names, part, gender) {
+    if (part.sub !== undefined) return names[part.list][part.sub];
     if (part.list !== GIVEN_LIST) return names[part.list];
     if (part.gender !== undefined) return names[GIVEN_LIST][part.gender];
     return givenNames(names, gender);