@heroiclands/package-build 25.1.2 → 25.2.0

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,
@@ -773,7 +773,8 @@ const NAMES_FIELD = Object.freeze({
         'builds a name from placeholders such as "{given} {clan}" and literal text, `given` ' +
         "maps a gender to a list of given names, " +
         `${wordList([...requiredGivenGenders()]).replace(" or ", " and ")} required, and ` +
-        "every other key is a list of names a placeholder of the same name draws from. A " +
+        "`en` holds groups of English names, and every other key is a list of names a " +
+        "placeholder of the same name draws from. A " +
         "language skill note only. See [name lists](format-details.md#name-lists).",
     fields: Object.freeze([
         Object.freeze({
@@ -783,7 +784,8 @@ const NAMES_FIELD = Object.freeze({
             shape: 'a pattern such as "{given} {clan}", a list of them, or a map of genders to either',
             describe:
                 "How a name is built: each `{list}` placeholder is filled from the list of " +
-                "that name, `{given.<gender>}` from that gender's given names, and the text " +
+                "that name, `{given.<gender>}` from that gender's given names, `{en.<list>}` from a " +
+                "list of English names, and the text " +
                 "around them is written as it stands. A list states every form a name may " +
                 "take; a map keyed by gender states each gender's forms, and a gender with " +
                 "none takes every pattern stated.",
@@ -822,6 +824,24 @@ const NAMES_FIELD = Object.freeze({
                 }),
             }),
         }),
+        Object.freeze({
+            name: "en",
+            kind: "map",
+            shape: "a map of list names to lists of English names",
+            describe:
+                "English names, never encoded in the tongue's script. A pattern draws from one " +
+                "list as `{en.<list>}`, as `{en.epithet}` does.",
+            values: Object.freeze({
+                kind: "list",
+                shape: "a list of English names",
+                describe: "A list of English names a placeholder draws from.",
+                entries: Object.freeze({
+                    kind: "string",
+                    shape: "a name",
+                    describe: "One English name, as written.",
+                }),
+            }),
+        }),
     ]),
     values: Object.freeze({
         kind: "list",
@@ -1015,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",
@@ -1079,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",
@@ -1896,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",
@@ -2445,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,
@@ -2455,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.

package/engine/settlement-tables.mjs

@@ -43,6 +43,7 @@ import { MARKET_CLASSES, marketClass } from "./market-class.mjs";
 import { hasTag } from "./note-vocabulary.mjs";
 import { shortcodesOf } from "./holdings.mjs";
 import { WIKILINK, parseWikilink } from "./wikilink-syntax.mjs";
+import { nameFormsOf } from "./name-forms.mjs";
 
 /** The heading text a settlements table stands under, at level two. */
 export const SETTLEMENTS_HEADING = "Settlements";
@@ -332,7 +333,7 @@ export function findSettlementTables(raw) {
  * @property {string} shortcode - Lower case.
  * @property {string} subType
  * @property {string} title
- * @property {Set<string>} names - Its name and aliases, lower case.
+ * @property {Set<string>} names - Its name and listed forms, lower case.
  * @property {string[]} parents - Enclosing places' shortcodes.
  * @property {{heading: number, tables: SettlementTable[]}} section
  */
@@ -353,7 +354,7 @@ export function findSettlementTables(raw) {
 const CORPUS = new WeakMap();
 
 /**
- * A note's name and aliases, lower case.
+ * A note's name and listed forms, lower case.
  *
  * @param {object} fm - The frontmatter.
  * @returns {Set<string>} The names.
@@ -367,7 +368,7 @@ function namesOf(fm) {
     if (typeof name === "string") add(name);
     else if (name && typeof name === "object") {
         add(name.full);
-        for (const alias of Array.isArray(name.aliases) ? name.aliases : []) add(alias);
+        for (const form of nameFormsOf(name)) add(form);
     }
     return out;
 }

package/engine/site-build.mjs

@@ -578,9 +578,6 @@ export function tableUniverse(pages) {
 /**
  * The frontmatter a page publishes with.
  *
- * An authored `aliases` is a list of names a reader might call the note. It is
- * dropped: this build emits no redirects.
- *
  * A content page carries the package the build **derived**. No note
  * declares one, so the note's frontmatter alone would publish a page that does
  * not say which package it belongs to. Writing the derived value keeps a page
@@ -589,9 +586,8 @@ export function tableUniverse(pages) {
  *
  * **`related` is derived, never authored.** What links to a page is a fact
  * about every other page, known only once the whole tree has resolved — see
- * {@link module:engine/related-pages} — so an authored value is dropped the
- * way `aliases` is, and {@link renderPages} sets the derived block once it
- * holds the graph.
+ * {@link module:engine/related-pages} — so an authored value is dropped, and
+ * {@link renderPages} sets the derived block once it holds the graph.
  *
  * @param {object} page - The page.
  * @param {object} options
@@ -621,7 +617,6 @@ export function pageFrontmatter(page, { decorate, webSrc, artSrc }) {
         kbfolder: page.folder,
     };
     if (decorate) decorate(data, page);
-    delete data.aliases;
     delete data.related;
     if (webSrc && artSrc) resolveArtFields(data, webSrc, artSrc);
     return data;

package/engine/site-search.mjs

@@ -30,7 +30,7 @@
  * the world. A note reached by more than one path carries every continent and
  * region it reaches, so a being with homes in two regions is found under both.
  *
- * The note's name and its aliases are weighted, so a search for a name finds
+ * The note's name and its listed forms are weighted, so a search for a name finds
  * its note first. A note's tags and its draft state are not filters.
  *
  * @module
@@ -38,6 +38,7 @@
 
 import { placeShortcodes } from "./map-places.mjs";
 import { resolveInfoboxRef } from "./site-index.mjs";
+import { nameFormsOf } from "./name-forms.mjs";
 
 /** The filters a note's page carries, in the order a reader is offered them. */
 export const SEARCH_FILTERS = Object.freeze([
@@ -153,9 +154,6 @@ export function searchMetadata(fm, { geography, index }) {
         values: values[name].filter(Boolean),
     })).filter((filter) => filter.values.length);
     const name = isMapping(fm?.name) ? fm.name : {};
-    const names = [
-        text(name.full),
-        ...(Array.isArray(name.aliases) ? name.aliases.map(text) : []),
-    ].filter(Boolean);
+    const names = [text(name.full), ...nameFormsOf(name).map(text)].filter(Boolean);
     return { filters, names: [...new Set(names)] };
 }

package/engine/site-theme.mjs

@@ -261,7 +261,7 @@ export function tableOfContents(headings) {
     return lines.join("\n");
 }
 
-/** How much more a page's name and aliases count in a search than a word of its body. */
+/** How much more a page's name and listed forms count in a search than a word of its body. */
 const NAME_WEIGHT = 10;
 
 /** The most `h2` headings a page may have before it gets a contents list. */