@heroiclands/package-build 25.1.2 → 25.2.0

package/engine/frontmatter-lint.mjs

@@ -55,6 +55,7 @@
 import { isAddressTuple } from "./address.mjs";
 import { listed, nearest } from "./near-miss.mjs";
 import { checkDataKeys } from "./data-keys.mjs";
+import { FALLBACK_LANGUAGE, normalizeName } from "./name-forms.mjs";
 import {
     authoredNoteKeys,
     CHARACTER_NAME_KEYS,
@@ -1165,6 +1166,9 @@ function checkEmbeddedShortcodes(note, blockName) {
  *   configuration through {@link systemBlocksFor}, and this module states no
  *   system name of its own. See {@link DEFAULT_SYSTEM_BLOCKS} for the fallback.
  * @param {object} [opts.addressContext] - Builder package and Address type vocabulary.
+ * @param {Iterable<string>} [opts.languages] - The language codes the
+ *   configuration's `languages:` declares. A `name` key that is one of them, or
+ *   `en`, is a list of forms; absent, only `en` is.
  * @param {readonly string[]} [opts.packs] - The pack names this package
  *   declares, for a `data:` field whose map is keyed by pack. Supplied by the
  *   caller like `schemas` and `vocabulary`, and absent it no claim is made
@@ -1181,6 +1185,7 @@ export function lintNote(
         packs,
         emittedArt,
         addressContext,
+        languages,
         systems = DEFAULT_SYSTEM_BLOCKS,
     },
 ) {
@@ -1254,15 +1259,17 @@ export function lintNote(
             if (type === "being" && fm.subType === "character") {
                 for (const key of CHARACTER_NAME_KEYS) allowed.add(key);
             }
+            const codes = new Set([FALLBACK_LANGUAGE, ...(languages ?? [])]);
             for (const key of Object.keys(name)) {
-                if (!allowed.has(key)) {
-                    findings.push({
-                        file: note.file,
-                        ...nameAt([key]),
-                        severity: "error",
-                        message: `\`name.${key}\` is not valid for this note`,
-                    });
-                }
+                if (allowed.has(key) || codes.has(key)) continue;
+                findings.push({
+                    file: note.file,
+                    ...nameAt([key]),
+                    severity: "error",
+                    message:
+                        `\`name.${key}\` is not valid for this note: a name lists its forms ` +
+                        `under a language code \`languages:\` declares, or \`${FALLBACK_LANGUAGE}\``,
+                });
             }
             if (typeof name.full !== "string" || !name.full.trim()) {
                 findings.push({
@@ -1272,18 +1279,34 @@ export function lintNote(
                     message: "`name.full` must be a nonempty string",
                 });
             }
-            if (Object.hasOwn(name, "aliases")) {
+            for (const code of Object.keys(name)) {
+                if (!codes.has(code) || allowed.has(code)) continue;
+                const forms = name[code];
                 if (
-                    !Array.isArray(name.aliases) ||
-                    name.aliases.some((alias) => typeof alias !== "string" || !alias.trim())
+                    !Array.isArray(forms) ||
+                    forms.some((form) => typeof form !== "string" || !form.trim())
                 ) {
                     findings.push({
                         file: note.file,
-                        ...nameAt(["aliases"]),
+                        ...nameAt([code]),
                         severity: "error",
-                        message: "`name.aliases` must be a list of nonempty strings",
+                        message: `\`name.${code}\` must be a list of nonempty strings`,
                     });
+                    continue;
                 }
+                if (code !== FALLBACK_LANGUAGE || typeof name.full !== "string") continue;
+                const full = normalizeName(name.full);
+                forms.forEach((form, i) => {
+                    if (normalizeName(form) !== full) return;
+                    findings.push({
+                        file: note.file,
+                        ...positionOfFrontmatterPath(raw(), ["name", code, i]),
+                        severity: "error",
+                        message:
+                            `\`name.${code}\` repeats \`name.full\` (${form}); \`full\` is ` +
+                            "already an English form, so leave it out",
+                    });
+                });
             }
             if (
                 Object.hasOwn(name, "sort") &&
@@ -1738,6 +1761,8 @@ export function lintNote(
  * @param {Readonly<Record<string, SystemBlockSpec>>} [opts.systems]
  *   The system blocks to check; see {@link lintNote} and
  *   {@link systemBlocksFor}.
+ * @param {Iterable<string>} [opts.languages] - The configured language codes,
+ *   which a note's `name` lists its forms under; see {@link lintNote}.
  * @param {readonly string[]} [opts.packs] - The declared pack names; see
  *   {@link lintNote}.
  * @param {(type: string) => {document: string|null, art: readonly string[]}|null} [opts.emittedArt]
@@ -1747,7 +1772,7 @@ export function lintNote(
  */
 export function lintFrontmatter(
     index,
-    { schemas, vocabulary, packs, emittedArt, references = true, systems, currentDate },
+    { schemas, vocabulary, packs, emittedArt, references = true, systems, currentDate, languages },
 ) {
     const findings = [];
     const notes = [...index.notes].sort((a, b) =>
@@ -1763,6 +1788,7 @@ export function lintFrontmatter(
                 currentDate,
                 packs,
                 emittedArt,
+                languages,
                 index: references ? index : undefined,
                 addressContext: {
                     package: index.contentPackage,

package/engine/glossary-entries.mjs

@@ -51,6 +51,7 @@ import {
     noteTerms,
 } from "./culture-reach.mjs";
 import { pronunciationProblem } from "./word-terms.mjs";
+import { noteLang } from "./glossary-language.mjs";
 
 /** Whether a value is a plain map. */
 const isMap = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -126,11 +127,10 @@ export function checkGlossary(note, { index } = {}) {
                     [i],
                     "error",
                     `\`${entry.name}\` resolves to no language: the entry states no ` +
-                        "`language`, and " +
-                        (type === "affiliation" ?
-                            "neither the affiliation, its parents nor its culture states one"
-                        :   "the culture states no `data.language`") +
-                        "; state `language` on the entry or `data.language` on the note",
+                        "`language`, and the note's language" +
+                        (noteLang(note) ? ` ${noteLang(note)}` : "") +
+                        " has no `note` in `languages:`; state `language` on the entry, or " +
+                        "`data.lang` on the note naming a language with a note",
                 ),
             );
         const senses = noteTerms(index, note, entry).get(name);

package/engine/glossary-language.mjs

@@ -16,16 +16,11 @@
  *
  * 1. the entry's own `language`;
  * 2. the note it is written on, when that note is a language;
- * 3. on an affiliation, its own `data.language`, then the nearest parent
- *    affiliation's (breadth first, parents in the order listed), then its
- *    culture's `data.language`;
- * 4. on a culture, its own `data.language`.
+ * 3. the language note of the code the content index derived for the note it
+ *    is written on, its `lang` — see {@link module:engine/note-language}.
  *
- * An affiliation's culture is the one the index resolves for it, its own or
- * one inherited through its parents, and a culture's language includes one it
- * inherits from its parent cultures. The lint and the `glossary` relation both
- * resolve through here, each handing over how it reads an Address and looks a
- * note up.
+ * The lint and the `glossary` relation both resolve through here, each handing
+ * over how it reads an Address, looks a note up and finds a code's note.
  *
  * A leaf module, importing nothing.
  *
@@ -35,12 +30,6 @@
 /** A note's parsed frontmatter, whichever shape the caller hands over. */
 const payload = (note) => note?.fm ?? note ?? {};
 
-/** A note's `data`, or an empty map. */
-const dataOf = (note) => {
-    const data = payload(note).data;
-    return data && typeof data === "object" && !Array.isArray(data) ? data : {};
-};
-
 /** A note's type or subType, lowercased. */
 const lower = (value) => String(value ?? "").toLowerCase();
 
@@ -51,11 +40,22 @@ const lower = (value) => String(value ?? "").toLowerCase();
  * @property {(value: unknown, type: string) => string|undefined} keyOf - A
  *   value's canonical Address in the `note` system, read with `type` as the
  *   default type, or `undefined` where it is no Address.
- * @property {(key: string) => object|undefined} lookup - The note an Address
- *   names, or `undefined` where none is known.
+ * @property {(code: string) => string|undefined} noteOf - The Address of a
+ *   language code's note, or `undefined` where no note is configured for it.
  * @property {string} [self] - The owning note's own Address, for a language.
  */
 
+/**
+ * The language a note is in, as the content index derived it.
+ *
+ * @param {object} note - An index record, or a link-index note carrying it.
+ * @returns {string|undefined} The code.
+ */
+export function noteLang(note) {
+    const lang = note?.lang;
+    return typeof lang === "string" && lang ? lang : undefined;
+}
+
 /**
  * The language a glossary entry resolves to.
  *
@@ -66,34 +66,11 @@ const lower = (value) => String(value ?? "").toLowerCase();
  * @returns {string|undefined} The language's Address, or `undefined` where the
  *   chain finds none.
  */
-export function glossaryLanguage(entry, owner, { keyOf, lookup, self }) {
+export function glossaryLanguage(entry, owner, { keyOf, noteOf, self }) {
     const own = keyOf(entry?.language, "skill");
     if (own) return own;
     const fm = payload(owner);
-    const type = lower(fm.type);
-    if (type === "skill" && lower(fm.subType) === "language") return self;
-    if (type === "lore" && lower(fm.subType) === "culture")
-        return keyOf(dataOf(owner).language, "skill");
-    if (type !== "affiliation") return undefined;
-
-    const seen = new Set();
-    let level = [owner];
-    while (level.length) {
-        const next = [];
-        for (const body of level) {
-            if (seen.has(body)) continue;
-            seen.add(body);
-            const language = keyOf(dataOf(body).language, "skill");
-            if (language) return language;
-            for (const parent of Array.isArray(dataOf(body).parents) ? dataOf(body).parents : []) {
-                const key = keyOf(parent, "affiliation");
-                const target = key ? lookup(key) : undefined;
-                if (target && lower(payload(target).type) === "affiliation") next.push(target);
-            }
-        }
-        level = next;
-    }
-    const culture = keyOf(dataOf(owner).culture, "lore");
-    const target = culture ? lookup(culture) : undefined;
-    return target ? keyOf(dataOf(target).language, "skill") : undefined;
+    if (lower(fm.type) === "skill" && lower(fm.subType) === "language") return self;
+    const code = noteLang(owner);
+    return code ? noteOf(code) : undefined;
 }

package/engine/homepage.mjs

@@ -355,9 +355,6 @@ export function homepageTitle(fm, config) {
  * **No `url` and no `slug`.** The homepage publishes at the package root, so
  * the page has no address to state.
  *
- * An authored `aliases` is dropped, as it is on every other page: this build
- * emits no redirects.
- *
  * `related` is derived like every other page's — what links to the homepage
  * is a fact about the rest of the tree — so an authored value is dropped and
  * the caller's block, where it has one, is set in its place.
@@ -372,7 +369,6 @@ export function homepageTitle(fm, config) {
  */
 export function homepageFrontmatter(fm, { contentPackage, title, related }) {
     const data = { ...fm, package: contentPackage, title };
-    delete data.aliases;
     delete data.related;
     if (related) data.related = related;
     return data;

package/engine/index-records.mjs

@@ -56,7 +56,9 @@ export const DERIVED_KEYS = Object.freeze([
     "address",
     "anchors",
     "nameAscii",
-    "aliasesAscii",
+    "formsAscii",
+    "lang",
+    "languageCode",
     "foundry",
     "documentation",
     "documents",

package/engine/infobox.mjs

@@ -129,6 +129,7 @@ import {
 } from "./standings.mjs";
 import { AddressEntries } from "./address-values.mjs";
 import { noteCalendar } from "./note-calendars.mjs";
+import { nameFormsOf } from "./name-forms.mjs";
 
 /**
  * How a section arranges what it holds.
@@ -288,6 +289,9 @@ export const NOTE_FIELD_PRESENTATION = Object.freeze({
         withheld: "template machinery, not a fact about the subject",
     }),
     id: Object.freeze({ withheld: "document identity machinery, not a fact about the subject" }),
+    lang: Object.freeze({
+        withheld: "language machinery, a code rather than a fact a reader follows",
+    }),
     pack: Object.freeze({ withheld: "compendium routing machinery, not a fact about the subject" }),
     packFolder: Object.freeze({
         withheld: "compendium routing machinery, not a fact about the subject",
@@ -1040,9 +1044,8 @@ function noteBox(
     const shown = new Set();
     const name = fm?.name?.full;
     if (hasValue(name)) rows.push({ label: "Name", kind: "text", value: String(name) });
-    if (Array.isArray(fm?.name?.aliases) && fm.name.aliases.length) {
-        rows.push({ label: "Aliases", kind: "list", value: fm.name.aliases });
-    }
+    const forms = nameFormsOf(fm?.name);
+    if (forms.length) rows.push({ label: "Other names", kind: "list", value: forms });
     if (fm?.type === "being" && Object.hasOwn(BEING_SUBTYPE_LABELS, fm.subType)) {
         rows.push({ label: "Type", kind: "text", value: BEING_SUBTYPE_LABELS[fm.subType] });
     }

package/engine/language-names.mjs

@@ -17,8 +17,9 @@
  *
  * A `skill` note of `subType: language` states them as `data.names`, and
  * `package-build npc new` draws a person's name from them, or checks a name it
- * is given against them. A culture reaches them through `data.language`, so
- * cultures sharing a tongue share its lists.
+ * is given against them. A culture reaches them through its language, the
+ * note `languages:` names for its `data.lang`, so cultures sharing a tongue
+ * share its lists.
  *
  * - `pattern` — the name's shape: placeholders such as `{given}` and `{clan}`,
  *   each naming a list, with literal text around them or directly against
@@ -33,6 +34,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 +60,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 +88,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 +135,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 +277,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 +413,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 +447,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 +549,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);

package/engine/language-rows.mjs

@@ -68,6 +68,7 @@ import {
     SOUND_CHANGE_STEP_KEYS,
     TONGUE_KEYS,
 } from "./language-terms.mjs";
+import { nameFormsOf } from "./name-forms.mjs";
 
 /** The columns every list relation opens with. */
 const IDENTITY = Object.freeze(["language", "position"]);
@@ -354,7 +355,7 @@ const soundsOf = (data) => (isMap(data.sounds) ? data.sounds : {});
 
 /**
  * Every name a note of the package carries, with the Addresses carrying it:
- * each string of a note's `name`, its aliases, an affiliation's rank and
+ * each string of a note's `name`, its listed forms, an affiliation's rank and
  * office titles, and the name of each anchor, cited with the anchor.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
@@ -371,12 +372,10 @@ function carriedNames(records) {
     for (const record of records) {
         const address = noteAddressOf(record);
         if (!address || record.documents || record.type === "folder") continue;
-        if (isMap(record.name))
-            for (const [key, value] of Object.entries(record.name)) {
-                if (key === "aliases" && Array.isArray(value))
-                    for (const alias of value) carry(alias, address);
-                else carry(value, address);
-            }
+        if (isMap(record.name)) {
+            for (const value of Object.values(record.name)) carry(value, address);
+            for (const form of nameFormsOf(record.name)) carry(form, address);
+        }
         const governance = isMap(record.data?.governance) ? record.data.governance : {};
         for (const rank of Array.isArray(governance.ranks) ? governance.ranks : [])
             if (isMap(rank)) carry(rank.title, address);

package/engine/lexical-sections.mjs

@@ -26,6 +26,7 @@ import { scanBlocks } from "./content-blocks.mjs";
 import { renderDictionary, renderGlossary } from "./dictionary-layout.mjs";
 import { DICTIONARY_COLUMNS, TERM_COLUMNS, dictionaryAndTermRows } from "./dictionary-rows.mjs";
 import { glossaryLanguage } from "./glossary-language.mjs";
+import { languageNotesByCode } from "./note-language.mjs";
 import { scanHeadingAttributes } from "./heading-attributes.mjs";
 import { isNoteRecord } from "./index-records.mjs";
 
@@ -117,6 +118,7 @@ export function lexicalSectionsFor(records, all = records) {
     const visible = encodeAddresses(records).filter(isNoteRecord);
     const complete = encodeAddresses(all).filter(isNoteRecord);
     const byKey = new Map(visible.map((record) => [keyOf(record), record]));
+    const languageNotes = languageNotesByCode(complete, keyOf);
     const addressContext = {
         types: new Set(complete.map((record) => record.type)),
         packages: new Set(complete.map((record) => record.package)),
@@ -136,7 +138,7 @@ export function lexicalSectionsFor(records, all = records) {
         const pageLanguage = glossaryLanguage(undefined, record, {
             self: key,
             keyOf: (value) => (typeof value === "string" ? value : undefined),
-            lookup: (address) => byKey.get(address),
+            noteOf: (code) => languageNotes.get(code),
         });
         sections.set(key, [
             {

package/engine/literature-notes.mjs

@@ -17,10 +17,8 @@
  * `data.culture`, is a field every lore note but a culture note may state,
  * declared in `culture-choice.mjs`.
  *
- * `data.language` is shared beyond literature: a work names the tongue it is
- * composed in, a culture the tongue its people speak, whose name lists
- * `package-build npc new` draws from, and an affiliation the trade, temple or
- * order tongue it keeps.
+ * The tongue a work is composed in is its `data.lang`, which every note may
+ * state.
  *
  * `DataFieldSpec` declares the keys a type accepts, not the subType that may
  * write them, so {@link checkLiteratureNote} scopes these keys to the subTypes
@@ -29,74 +27,13 @@
  * @module
  */
 
-import { isAddressTuple, parseAddress, renderAddress } from "./address.mjs";
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
 
 /** The `lore` subType whose notes are works of literature. */
 export const LITERATURE_SUBTYPE = "literature";
 
-/** The `lore` subTypes that may name a language. */
-export const LANGUAGE_SUBTYPES = Object.freeze([LITERATURE_SUBTYPE, "culture"]);
-
-/**
- * Require `data.language` to address a `skill` note whose subType is
- * `language`.
- *
- * An Address that does not resolve is the reference check's to report, so
- * this speaks only about a target that exists and is the wrong kind.
- *
- * @param {object} note
- * @param {{index?: object}} [options]
- * @returns {object[]} The findings.
- */
-export function checkLanguageChoice(note, { index } = {}) {
-    const value = note.fm?.data?.language;
-    if (value === undefined || value === null || !index?.addressHit) return [];
-    const tuple = parseAddress(value, {
-        package: index.contentPackage,
-        system: "note",
-        type: "skill",
-        types: index.types,
-        packages: index.packages,
-    });
-    if (tuple.reason) return [];
-    const target = index.addressHit(renderAddress(tuple));
-    if (!target) return [];
-    const fm = target.fm ?? target;
-    if (tuple.type === "skill" && fm.subType === "language") return [];
-    return [
-        {
-            file: note.file,
-            ...positionOfFrontmatterPath(note.raw ?? "", ["data", "language"]),
-            severity: "error",
-            message: `data.language ${isAddressTuple(value) ? renderAddress(value) : value} names a note that is not a skill whose subType is language`,
-        },
-    ];
-}
-
-/**
- * `data.language`: the tongue a work is composed in, the tongue a culture's
- * people speak, or the tongue an affiliation keeps. Optional on all three.
- *
- * @type {object}
- */
-export const LANGUAGE_FIELD = Object.freeze({
-    name: "language",
-    shape: "an Address",
-    kind: "address",
-    ref: "skill",
-    accepts: Object.freeze(["skill"]),
-    check: checkLanguageChoice,
-    describe:
-        "The tongue the note is in, as a language skill note: the tongue a work is composed " +
-        "in, a culture's people speak, or an affiliation keeps as its trade, temple or order " +
-        "tongue. `package-build npc new` draws a culture's names from its language's " +
-        "`data.names`. A `literature` or `culture` lore note, or an affiliation, only.",
-});
-
 /**
- * The fields only a `literature` note may state, beside the shared
- * {@link LANGUAGE_FIELD}. Every one is optional.
+ * The fields only a `literature` note may state. Every one is optional.
  *
  * @type {ReadonlyArray<object>}
  */
@@ -124,8 +61,7 @@ export const LITERATURE_FIELDS = Object.freeze([
 const LITERATURE_KEYS = Object.freeze(LITERATURE_FIELDS.map((field) => field.name));
 
 /**
- * Refuse a literature field on a lore note of any other subType, and
- * `data.language` on a lore note that is neither a work nor a culture.
+ * Refuse a literature field on a lore note of any other subType.
  *
  * @param {object} note
  * @returns {object[]} One error per key written off the subTypes that take it.
@@ -153,13 +89,5 @@ export function checkLiteratureNote(note) {
                         `\`subType\` is not \`literature\``,
                 ),
             );
-    if (!LANGUAGE_SUBTYPES.includes(subType) && stated(LANGUAGE_FIELD.name))
-        findings.push(
-            finding(
-                LANGUAGE_FIELD.name,
-                "`data.language` names the tongue of a work of literature or of a culture, " +
-                    "and this note's `subType` is neither `literature` nor `culture`",
-            ),
-        );
     return findings;
 }