@heroiclands/package-build 25.1.3 → 25.2.0

package/engine/name-rows.mjs

@@ -22,7 +22,15 @@ import { encodeAddresses } from "./address-values.mjs";
 import { isNoteRecord } from "./index-records.mjs";
 
 /** Every column of the `names` relation, in order. */
-export const NAME_COLUMNS = Object.freeze(["owner", "name", "type", "subType", "line", "column"]);
+export const NAME_COLUMNS = Object.freeze([
+    "owner",
+    "name",
+    "type",
+    "subType",
+    "ref",
+    "line",
+    "column",
+]);
 
 /**
  * @typedef {object} NameRow
@@ -30,6 +38,7 @@ export const NAME_COLUMNS = Object.freeze(["owner", "name", "type", "subType", "
  * @property {string} name - Rendered visible text of the occurrence.
  * @property {string|null} type - Supplied note type, or null.
  * @property {string|null} subType - Supplied subtype, or null.
+ * @property {string|null} ref - The `ref=` as written, a note address or a page-local `#key`, or null.
  * @property {number} line - Original 1-based source line at the opening bracket.
  * @property {number} column - Original 1-based UTF-16 source column at that bracket.
  */
@@ -61,6 +70,7 @@ export function namesRows(records) {
                 name: entry.name,
                 type: entry.type ?? null,
                 subType: entry.subType ?? null,
+                ref: entry.ref ?? null,
                 line: entry.line,
                 column: entry.column,
             });

package/engine/names.mjs

@@ -19,7 +19,9 @@ import { formatLocator } from "./diagnostics.mjs";
 import { FOLDER_TYPE } from "./folder-notes.mjs";
 import { isNoteRecord } from "./index-records.mjs";
 import { NOTE_VOCABULARY } from "./note-vocabulary.mjs";
+import { readNameRef } from "./name-refs.mjs";
 import { WORD } from "./word-pattern.mjs";
+import { displayName, nameFormsOf, normalizeName } from "./name-forms.mjs";
 
 const compare = (a, b) =>
     a < b ? -1
@@ -32,7 +34,7 @@ const compare = (a, b) =>
  * @property {string} key - Canonical page identity, or the ambiguous label identity.
  * @property {string} full - Declared full name.
  * @property {true} indexed - The identity belongs to the indexed catalog.
- * @property {boolean} [fullUse] - The label is a full-name form rather than an alias.
+ * @property {boolean} [fullUse] - The label is a form of the full name rather than a listed form.
  * @property {string} [type] - The note's type, absent on an ambiguous label identity.
  * @property {string|null} [subType] - The note's subtype, or null.
  * @property {NameMatch[]} [candidates] - Indexed identities sharing the label.
@@ -40,7 +42,7 @@ const compare = (a, b) =>
  */
 
 /**
- * The prepared name and declared-alias lookup.
+ * The prepared lookup of full names and listed forms.
  * @typedef {object} NameCatalog
  * @property {(label: string, preferred?: {key: string}, kind?: NameKind) => NameMatch|undefined} recognize - Match a whole visible label, among notes of `kind` when it supplies a type.
  * @property {(target: string) => NameMatch|undefined} resolve - Resolve an Address target without its anchor to its indexed identity.
@@ -60,6 +62,7 @@ const compare = (a, b) =>
  * @property {string} name - Rendered visible text.
  * @property {string|null} type - Supplied valid type, or null.
  * @property {string|null} subType - Supplied valid subtype, or null.
+ * @property {string|null} ref - The `ref=` as written, a note address or a `#key`, or null.
  * @property {number} line - Original 1-based file line.
  * @property {number} column - Original 1-based UTF-16 file column.
  */
@@ -116,19 +119,14 @@ const compare = (a, b) =>
  * @property {NameConflict[]} conflicts - Labels with incompatible supplied kinds.
  */
 
-/**
- * Normalize a whole visible label without folding its case.
- * @param {string} text - Visible name or declared alias.
- * @returns {string} NFC text with straight apostrophes and single spaces.
- */
-export function normalizeName(text) {
-    return text.normalize("NFC").replaceAll("’", "'").replace(/\s+/g, " ").trim();
-}
+// A label's matching key folds case; its display form keeps it.
+export { displayName, normalizeName } from "./name-forms.mjs";
 
 /**
- * Whole-label possessives and regular plurals; other forms are declared aliases.
- * @param {string} text - Full name or declared alias.
- * @returns {string[]} Supported whole-label forms.
+ * Whole-label possessives and regular plurals, as matching keys; any other
+ * form is one a note's name lists.
+ * @param {string} text - Full name or a listed form.
+ * @returns {string[]} Supported whole-label forms, case folded.
  */
 export function nameForms(text) {
     const value = normalizeName(text);
@@ -150,7 +148,7 @@ function identity(record) {
 }
 
 /**
- * Prepare full names, declared aliases and link identities from captured records.
+ * Prepare full names, every listed form and link identities from captured records.
  * @param {object} options - The invocation's existing corpus and link index.
  * @param {readonly object[]} options.records - Captured local records.
  * @param {ReturnType<typeof import("./content-links.mjs").buildLinkIndex>} options.index - Captured address space.
@@ -160,7 +158,7 @@ export function createNameCatalog({ records, index }) {
     const names = new Map(),
         byFile = new Map(),
         entries = new Map();
-    const addName = (key, full, aliases, type, subType) => {
+    const addName = (key, full, forms, type, subType) => {
         const entry = entries.get(key) ?? {
             key,
             full,
@@ -169,7 +167,7 @@ export function createNameCatalog({ records, index }) {
             subType: typeof subType === "string" && subType ? subType : null,
         };
         entries.set(key, entry);
-        for (const text of [full, ...(aliases ?? [])]) {
+        for (const text of [full, ...(forms ?? [])]) {
             if (typeof text !== "string" || !text.trim()) continue;
             for (const spelling of nameForms(text)) {
                 if (!names.has(spelling)) names.set(spelling, new Map());
@@ -192,7 +190,7 @@ export function createNameCatalog({ records, index }) {
         const entry = addName(
             index.resolve(page) ? page : canonical,
             full,
-            record.name.aliases,
+            nameFormsOf(record.name),
             parts.type,
             record.subType,
         );
@@ -211,7 +209,10 @@ export function createNameCatalog({ records, index }) {
             continue;
         const page = canonicalKey(parts.package, "note", parts.type, parts.shortcode);
         const key = index.foreign.index.has(page) ? page : canonical;
-        entries.set(canonical, addName(key, hit.name, hit.aliases, parts.type, hit.subType));
+        entries.set(
+            canonical,
+            addName(key, hit.name, nameFormsOf(hit.forms), parts.type, hit.subType),
+        );
     }
     return {
         recognize(label, preferred, kind) {
@@ -302,8 +303,9 @@ export function collectUnwrittenNames({ records, catalog }) {
             if (!kinds.has(kind)) kinds.set(kind, { type, subType, names: new Map() });
             const names = kinds.get(kind).names,
                 name = normalizeName(occurrence.name);
-            if (!names.has(name)) names.set(name, []);
-            names.get(name).push(nameUse(record, occurrence));
+            if (!names.has(name))
+                names.set(name, { display: displayName(occurrence.name), uses: [] });
+            names.get(name).uses.push(nameUse(record, occurrence));
         }
     }
     const groups = [...kinds.values()]
@@ -316,7 +318,7 @@ export function collectUnwrittenNames({ records, catalog }) {
             subType,
             names: [...names]
                 .sort(([a], [b]) => compare(a, b))
-                .map(([name, uses]) => ({ name, uses: uses.sort(compareUses) })),
+                .map(([, { display, uses }]) => ({ name: display, uses: uses.sort(compareUses) })),
         }));
     const firstUse = firstNameUse(
         groups.flatMap((group) => group.names.flatMap((name) => name.uses)),
@@ -383,6 +385,7 @@ export function analyzeNameSpans(spans, { file, vocabulary = NOTE_VOCABULARY, ty
             name: span.visible,
             type: kind.type,
             subType: kind.subType,
+            ref: readNameRef(span),
             line: span.line,
             column: span.column,
         });
@@ -401,11 +404,13 @@ export function analyzeNameSpans(spans, { file, vocabulary = NOTE_VOCABULARY, ty
  */
 export function createNamesReport({ package: contentPackage, records, catalog }) {
     const names = new Map();
+    const displays = new Map();
     for (const record of records.filter(isNoteRecord))
         for (const occurrence of record.names ?? []) {
             if (occurrence.type === null) continue;
             const name = normalizeName(occurrence.name);
             if (!names.has(name)) names.set(name, new Map());
+            if (!displays.has(name)) displays.set(name, displayName(occurrence.name));
             const kinds = names.get(name),
                 key = JSON.stringify([occurrence.type, occurrence.subType]);
             if (!kinds.has(key))
@@ -421,7 +426,7 @@ export function createNamesReport({ package: contentPackage, records, catalog })
         }
         if (parents.size < 2 && ![...parents.values()].some((values) => values.size > 1)) continue;
         conflicts.push({
-            name,
+            name: displays.get(name),
             kinds: [...kinds.values()]
                 .sort(
                     (a, b) => compare(a.type, b.type) || compare(a.subType ?? "", b.subType ?? ""),

package/engine/note-addresses.mjs

@@ -159,9 +159,6 @@ export function addressPositions(fm, context = {}) {
                 ...(ASSET_TYPE_NAMES.has(field.ref) || field.ref === "folder" ?
                     { system: "none" }
                 :   {}),
-                ...(field.name === "language" && field.ref === "skill" ?
-                    { system: NOTE_SYSTEM, noteOnly: true }
-                :   {}),
             });
     }
     out.push(...STRUCTURED_ADDRESSES.filter((p) => !p.noteType || p.noteType === fm.type));

package/engine/note-frontmatter.mjs

@@ -21,11 +21,9 @@ export {
     NOTE_TOP_LEVEL_KEY_SET,
 } from "./note-vocabulary.mjs";
 
-/** The name properties every note accepts, in display order. */
-export const NOTE_NAME_KEYS = Object.freeze(["full", "aliases", "sort"]);
-
-/** Additional name components accepted by an individual character. */
-export const CHARACTER_NAME_KEYS = Object.freeze(["given", "clan"]);
+// The single-string name keys, beside the language form lists they are told
+// apart from.
+export { CHARACTER_NAME_KEYS, NOTE_NAME_KEYS } from "./name-forms.mjs";
 
 /** Return authored keys from an opening YAML frontmatter map. */
 export function authoredNoteKeys(markdown) {

package/engine/note-language.mjs

@@ -0,0 +1,348 @@
+/*
+ * 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
+ */
+
+/**
+ * **The language a note is in**, a code `languages:` declares or `en`. A
+ * note's language is the first of:
+ *
+ * 1. its own `data.lang`;
+ * 2. its `data.culture`'s language: the culture note it names, resolved by
+ *    these same rules;
+ * 3. its `data.parents`, nearest first, each resolved by these same rules;
+ * 4. `en`.
+ *
+ * Steps 2 and 3 take only a language some note states: a culture or parent
+ * that itself falls through to `en` contributes nothing, and the chain goes on.
+ * A parent in another package contributes the language its published entry
+ * carries.
+ *
+ * The content index writes the result onto every note record as `lang`, and
+ * every reader of a note's language reads it from there. The configured
+ * language note of each code carries that code as `languageCode`, so a reader
+ * holding only records maps a code to its note.
+ *
+ * Findings, each an error:
+ *
+ * - a `data.lang` naming no declared code, at its value;
+ * - a `data.culture` whose culture resolves to no language, at its value;
+ * - every `data.parents` entry on a cycle, at the entry, whether or not a walk
+ *   reaches it. A cycle among culture notes is reported by the culture
+ *   hierarchy check instead.
+ *
+ * @module
+ */
+
+import fs from "node:fs";
+
+import { canonicalKey, isAddressTuple, parseAddress, renderAddress } from "./address.mjs";
+import { isAddressSegment } from "./address-charset.mjs";
+import { AddressLink } from "./address-values.mjs";
+import { formatDiagnostic, positionOfFrontmatterPath } from "./diagnostics.mjs";
+import { isNoteRecord, noteFile } from "./index-records.mjs";
+import { FALLBACK_LANGUAGE } from "./name-forms.mjs";
+import { NOTE_SYSTEM } from "./systems.mjs";
+
+/**
+ * The canonical key an Address names, without any anchor.
+ *
+ * @param {unknown} value - A tuple, an {@link AddressLink}, or anything else.
+ * @returns {string|undefined} The key, or `undefined` for anything else.
+ */
+function addressKey(value) {
+    const tuple = value instanceof AddressLink ? value.target : value;
+    return isAddressTuple(tuple) ? renderAddress(tuple) : undefined;
+}
+
+/**
+ * Whether a record is a culture note.
+ *
+ * @param {Record<string, any>|undefined} record - An index record.
+ * @returns {boolean} Whether it is a `lore` note with `subType: culture`.
+ */
+function isCultureNote(record) {
+    return record?.type === "lore" && String(record.subType ?? "").toLowerCase() === "culture";
+}
+
+/**
+ * Write each note's language onto its record as `lang`, and each configured
+ * language note's code onto its record as `languageCode`.
+ *
+ * Reads each note's authored `data.lang`, `data.culture` and `data.parents`,
+ * so it runs before the index writes a resolved culture over `data.culture`.
+ *
+ * @param {Array<Record<string, any>>} records - Index records, every Address a
+ *   tuple. Records that are not notes are passed over.
+ * @param {object} options - Options.
+ * @param {string} options.contentPackage - The package the records belong to.
+ * @param {Readonly<Record<string, {note?: string}>>} [options.languages] - The
+ *   configured languages, by code.
+ * @param {string} [options.contentBase] - The content tree, for opening a note
+ *   to locate a finding.
+ * @param {(key: string) => Record<string, any>|undefined} [options.foreignRecord] -
+ *   Another package's entry for a canonical address.
+ * @param {object[]} [options.problems] - Receives each finding. Omitted, the
+ *   findings are collected and one Error lists them all.
+ * @param {Map<string, {raw: string}>} [options.parsed] - Notes already read, keyed by file.
+ * @returns {Array<Record<string, any>>} The same records.
+ * @throws {Error} When `problems` is omitted and anything is reported.
+ */
+export function resolveNoteLanguages(
+    records,
+    { contentPackage, languages, contentBase, foreignRecord, problems, parsed },
+) {
+    const codes = new Set([FALLBACK_LANGUAGE, ...Object.keys(languages ?? {})]);
+    const notes = new Map();
+    for (const record of records) {
+        if (!isNoteRecord(record) || !isAddressSegment(String(record.shortcode ?? ""))) continue;
+        const key = canonicalKey(contentPackage, NOTE_SYSTEM, record.type, record.shortcode);
+        if (!notes.has(key)) notes.set(key, record);
+    }
+    const localOf = (value) => {
+        const tuple = value instanceof AddressLink ? value.target : value;
+        if (!isAddressTuple(tuple) || tuple.package !== contentPackage) return undefined;
+        return notes.get(canonicalKey(contentPackage, NOTE_SYSTEM, tuple.type, tuple.shortcode));
+    };
+
+    const findings = [];
+    /**
+     * Report one finding on a note, at a frontmatter value.
+     *
+     * @param {Record<string, any>} record - The note.
+     * @param {Array<string|number>} keyPath - Where the value is written.
+     * @param {string} message - What is wrong.
+     */
+    const report = (record, keyPath, message) => {
+        const file = contentBase ? noteFile(contentBase, record) : record.file?.path;
+        const raw =
+            parsed?.get(file)?.raw ??
+            (contentBase && fs.existsSync(file) ? fs.readFileSync(file, "utf8") : undefined);
+        findings.push({
+            file,
+            ...positionOfFrontmatterPath(raw, keyPath),
+            severity: "error",
+            message,
+        });
+    };
+
+    const memo = new Map();
+    const inProgress = new Set();
+
+    /**
+     * The language a source Address states: a local note's, resolved, or the
+     * one a foreign entry publishes.
+     *
+     * @param {unknown} value - A `data.culture` or `data.parents` Address.
+     * @returns {string|undefined} The code.
+     */
+    const statedThrough = (value) => {
+        const key = addressKey(value);
+        if (!key) return undefined;
+        const local = localOf(value);
+        if (local) return resolve(local);
+        const tuple = value instanceof AddressLink ? value.target : value;
+        if (tuple.package === contentPackage) return undefined;
+        const lang = foreignRecord?.(key)?.lang;
+        return typeof lang === "string" && lang ? lang : undefined;
+    };
+
+    /**
+     * The language a note states through its own field, its culture or its
+     * parents, ignoring the fallback.
+     *
+     * @param {Record<string, any>} record - The note.
+     * @returns {string|undefined} The code.
+     */
+    const resolveRecord = (record) => {
+        const own = record.data?.lang;
+        if (own !== undefined && own !== null) {
+            if (typeof own === "string" && codes.has(own)) return own;
+            report(
+                record,
+                ["data", "lang"],
+                `data.lang ${typeof own === "string" ? own : JSON.stringify(own)} names no ` +
+                    `language: state a code \`languages:\` declares, or ${FALLBACK_LANGUAGE} ` +
+                    `(${[...codes].sort().join(", ")})`,
+            );
+        }
+        const culture = record.data?.culture;
+        const cultureRecord = localOf(culture);
+        if (addressKey(culture) && cultureRecord !== record) {
+            const lang = statedThrough(culture);
+            if (lang) return lang;
+            if (isCultureNote(cultureRecord) && !inProgress.has(cultureRecord))
+                report(
+                    record,
+                    ["data", "culture"],
+                    `data.culture ${cultureRecord.type}-${cultureRecord.shortcode} resolves to ` +
+                        "no language: state data.lang on the culture or on a parent culture",
+                );
+        }
+        const parents = Array.isArray(record.data?.parents) ? record.data.parents : [];
+        for (const [position, parent] of parents.entries()) {
+            const target = localOf(parent);
+            if (target && inProgress.has(target)) continue;
+            const lang = statedThrough(parent);
+            if (lang) return lang;
+        }
+        return undefined;
+    };
+
+    /**
+     * A local note's stated language, memoised; a note already being resolved
+     * is a cycle and states nothing.
+     *
+     * @param {Record<string, any>} record - The note.
+     * @returns {string|undefined} The code.
+     */
+    const resolve = (record) => {
+        if (memo.has(record)) return memo.get(record);
+        if (inProgress.has(record)) return undefined;
+        inProgress.add(record);
+        const result = resolveRecord(record);
+        inProgress.delete(record);
+        memo.set(record, result);
+        return result;
+    };
+
+    // Walked in address order, so which note of a cycle is met first is a fact
+    // about the content rather than about directory-read order.
+    for (const key of [...notes.keys()].sort()) resolve(notes.get(key));
+
+    // Every `data.parents` entry on a cycle, whether or not a walk reached it.
+    for (const { record, position, target } of cyclicParents(notes, localOf))
+        if (!(isCultureNote(record) && isCultureNote(target)))
+            report(
+                record,
+                ["data", "parents", position],
+                `data.parents.${position} names ${target.type}-${target.shortcode}, ` +
+                    "which closes a parents cycle; a note is never its own ancestor",
+            );
+    for (const record of records) {
+        if (!isNoteRecord(record) || !isAddressSegment(String(record.shortcode ?? ""))) continue;
+        const own = notes.get(
+            canonicalKey(contentPackage, NOTE_SYSTEM, record.type, record.shortcode),
+        );
+        record.lang = memo.get(own) ?? FALLBACK_LANGUAGE;
+    }
+
+    // Each configured language note carries its code.
+    const types = new Set(["skill", ...records.map((record) => String(record.type ?? ""))]);
+    for (const [code, spec] of Object.entries(languages ?? {})) {
+        if (typeof spec?.note !== "string") continue;
+        const tuple = parseAddress(spec.note, {
+            package: contentPackage,
+            system: NOTE_SYSTEM,
+            type: "skill",
+            types,
+        });
+        const record = tuple.reason ? undefined : localOf(tuple);
+        if (record) record.languageCode = code;
+    }
+
+    findings.sort(
+        (a, b) =>
+            String(a.file).localeCompare(String(b.file), "en") ||
+            (a.line ?? 0) - (b.line ?? 0) ||
+            (a.column ?? 0) - (b.column ?? 0),
+    );
+    if (problems) problems.push(...findings);
+    else if (findings.length)
+        throw Object.assign(new Error(findings.map(formatDiagnostic).join("\n")), {
+            located: true,
+        });
+    return records;
+}
+
+/**
+ * Every local `data.parents` entry that lies on a cycle: its target reaches
+ * its note again through `data.parents`.
+ *
+ * @param {Map<string, Record<string, any>>} notes - Local notes by key.
+ * @param {(value: unknown) => Record<string, any>|undefined} localOf - The
+ *   local note an Address names.
+ * @returns {Array<{record: Record<string, any>, position: number, target: Record<string, any>}>}
+ *   The entries, in note-key then list order.
+ */
+function cyclicParents(notes, localOf) {
+    const edges = new Map();
+    for (const record of notes.values()) {
+        const parents = Array.isArray(record.data?.parents) ? record.data.parents : [];
+        edges.set(
+            record,
+            parents
+                .map((parent, position) => ({ position, target: localOf(parent) }))
+                .filter((edge) => edge.target),
+        );
+    }
+    // Tarjan's strongly connected components: an edge inside one component,
+    // or from a note to itself, lies on a cycle.
+    const index = new Map();
+    const low = new Map();
+    const component = new Map();
+    const stack = [];
+    const onStack = new Set();
+    let counter = 0;
+    const visit = (record) => {
+        index.set(record, counter);
+        low.set(record, counter);
+        counter++;
+        stack.push(record);
+        onStack.add(record);
+        for (const { target } of edges.get(record) ?? []) {
+            if (!index.has(target)) {
+                visit(target);
+                low.set(record, Math.min(low.get(record), low.get(target)));
+            } else if (onStack.has(target))
+                low.set(record, Math.min(low.get(record), index.get(target)));
+        }
+        if (low.get(record) !== index.get(record)) return;
+        let member;
+        do {
+            member = stack.pop();
+            onStack.delete(member);
+            component.set(member, record);
+        } while (member !== record);
+    };
+    const keys = [...notes.keys()].sort();
+    for (const key of keys) if (!index.has(notes.get(key))) visit(notes.get(key));
+    const out = [];
+    for (const key of keys) {
+        const record = notes.get(key);
+        for (const { position, target } of edges.get(record) ?? [])
+            if (target === record || component.get(target) === component.get(record))
+                out.push({ record, position, target });
+    }
+    return out;
+}
+
+/**
+ * Each language code's note, read from records alone: the Address of every
+ * record carrying a `languageCode`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records, local and
+ *   any dependency's, or link-index notes carrying them.
+ * @param {(record: Record<string, any>) => string|undefined} addressOf - A
+ *   record's Address, as the caller keys notes.
+ * @returns {Map<string, string>} Code to the language note's Address; the first
+ *   record naming a code wins.
+ */
+export function languageNotesByCode(records, addressOf) {
+    const out = new Map();
+    for (const record of records) {
+        const code = record?.languageCode;
+        if (typeof code !== "string" || out.has(code)) continue;
+        const address = addressOf(record);
+        if (address) out.set(code, address);
+    }
+    return out;
+}

package/engine/note-vocabulary.mjs

@@ -125,7 +125,7 @@ import {
     requiredHeightGenders,
 } from "./appearance-profile.mjs";
 import { checkExtraFeatures } from "./appearance-features.mjs";
-import { LANGUAGE_FIELD, LITERATURE_FIELDS, checkLiteratureNote } from "./literature-notes.mjs";
+import { LITERATURE_FIELDS, checkLiteratureNote } from "./literature-notes.mjs";
 import {
     AFFIX_FIELDS,
     GLOSSARY_ENTRY_FIELDS,
@@ -1035,7 +1035,9 @@ export const NOTE_TOP_LEVEL_FIELDS = Object.freeze([
     }),
     Object.freeze({
         name: "name",
-        describe: "The display names — a required `full`, and any `aliases` and `sort`.",
+        describe:
+            "The display names — a required `full`, the English name; the other names, " +
+            "listed under the code of their language; and any `sort`.",
     }),
     Object.freeze({
         name: "type",
@@ -1099,6 +1101,14 @@ export const NOTE_TOP_LEVEL_KEY_SET = Object.freeze(new Set(NOTE_TOP_LEVEL_KEYS)
  * @type {readonly DataFieldSpec[]}
  */
 export const SHARED_DATA_FIELDS = Object.freeze([
+    Object.freeze({
+        name: "lang",
+        kind: "string",
+        shape: "a language code `languages:` declares, or `en`",
+        describe:
+            "The language the note is in. Absent, the content index derives it: the " +
+            "note's culture's language, then its `data.parents`' nearest first, then `en`.",
+    }),
     Object.freeze({
         name: "seeAlso",
         kind: "list",
@@ -1916,13 +1926,6 @@ export const NOTE_VOCABULARY = Object.freeze({
                 ...CULTURE_FIELD,
                 describe: "The people this affiliation belongs to, as a culture lore note.",
             },
-            {
-                ...LANGUAGE_FIELD,
-                describe:
-                    "The trade, temple or order tongue the affiliation keeps, as a language " +
-                    "skill note. A glossary entry that states no `language` is in it. The " +
-                    "affiliation chooses its own common vocabulary and context meanings.",
-            },
             GLOSSARY_FIELD,
             {
                 name: "relations",
@@ -2465,7 +2468,7 @@ export const NOTE_VOCABULARY = Object.freeze({
                 accepts: ["lore"],
                 check: checkCultureParents,
                 describe:
-                    "Culture only: parent culture lore notes, searched in listed depth-first order for omitted language and appearance profile fields.",
+                    "Culture only: parent culture lore notes, searched in listed depth-first order for an omitted appearance profile, and nearest first for an omitted `data.lang`.",
             },
             {
                 ...CULTURE_FIELD,
@@ -2475,7 +2478,6 @@ export const NOTE_VOCABULARY = Object.freeze({
                     "culture, and states the field only as itself.",
             },
             ...LITERATURE_FIELDS,
-            LANGUAGE_FIELD,
             EVENTS_FIELD,
             APPEARANCE_PROFILE_FIELD,
             {

package/engine/pdf-index.mjs

@@ -28,7 +28,7 @@
  * - A note whose name opens with one of the book's `pdf.indexHeads` is also
  *   filed under the rest of its name, with the head after a comma
  *   (`Targud, Kingdom of`), and that entry carries the note's pages.
- * - An alias (`name.aliases`) and an event's in-world name
+ * - A listed name form (`name.<code>`) and an event's in-world name
  *   (`data.events[].names`) list a cross-reference to the note's name.
  *
  * Terms sort on the ASCII fold the content index derives for names
@@ -42,6 +42,7 @@
  */
 
 import { asciiName, nameSortOf } from "./name-sort.mjs";
+import { nameFormsOf } from "./name-forms.mjs";
 
 /**
  * The marker an entry heading or an authored mention carries.
@@ -153,7 +154,7 @@ export function indexTerms(entries, { owns = () => true, foreign = [], heads = [
             terms.push({ name: inverted, slug, main: false, inverted: true });
         }
         const names = [
-            ...(Array.isArray(entry.record?.name?.aliases) ? entry.record.name.aliases : []),
+            ...nameFormsOf(entry.record?.name),
             ...(Array.isArray(entry.record?.data?.events) ? entry.record.data.events : []).flatMap(
                 (event) => (Array.isArray(event?.names) ? event.names.map((n) => n?.name) : []),
             ),

package/engine/pdf-render.mjs

@@ -2012,11 +2012,9 @@ export function bookTypstPreamble(runs = {}, families = {}) {
             "  }\n" +
             "  if lang != none { text(lang: lang, styled) } else { styled }\n" +
             "}",
-        // Span classes reach the book intact; name styling sets an absolute
-        // weight so it remains bold inside an ordinary strong phrase.
+        // Span classes reach the book intact.
         "#let book-span(body, classes: (), lang: none) = {\n" +
-            '  let styled = if classes.contains("name") { text(weight: "bold", body) } else { body }\n' +
-            "  box(book-script-text(styled, classes: classes, lang: lang))\n" +
+            "  box(book-script-text(body, classes: classes, lang: lang))\n" +
             "}",
         // Use the file's natural measure for auto. Every requested width is
         // bounded by the available measure and by the height of a page.