@heroiclands/package-build 25.1.3 → 25.2.1

package/engine/sql-tables.mjs

@@ -55,6 +55,7 @@ import { LANGUAGE_COLUMN_TYPES, LANGUAGE_RELATIONS } from "./language-rows.mjs";
 import { VERB_PERSON_FIELDS } from "./language-terms.mjs";
 import { renderDictionary, renderGlossary } from "./dictionary-layout.mjs";
 import { glossaryLanguage } from "./glossary-language.mjs";
+import { languageNotesByCode } from "./note-language.mjs";
 import { lexicalSectionsFor } from "./lexical-sections.mjs";
 import { eventViewSections } from "./event-views.mjs";
 import { appendGeneratedSections, joinSections } from "./generated-sections.mjs";
@@ -466,6 +467,22 @@ export async function openNotesDatabase(
             system: "note",
         },
         stubsExcluded,
+        // Each language code's note, for a page whose language is read from
+        // its frontmatter.
+        languageNotes: languageNotesByCode(encoded, (record) =>
+            (
+                typeof record.package === "string" &&
+                typeof record.type === "string" &&
+                typeof record.shortcode === "string"
+            ) ?
+                renderAddress({
+                    package: record.package,
+                    system: "note",
+                    type: record.type,
+                    shortcode: record.shortcode,
+                })
+            :   undefined,
+        ),
         async query(sql) {
             const reader = await connection.runAndReadAll(sql);
             return {
@@ -1019,7 +1036,7 @@ function toPlain(value) {
  * DuckDB returns an integer as a `BigInt`, which `String()` renders without its
  * `n` — but a struct or a list would stringify as `[object Object]`, so those
  * are refused rather than printed. A list of scalars is joined, because that is
- * what a `tags` or `aliases` column means.
+ * what a `tags` column means.
  *
  * @param {unknown} value - The cell value.
  * @param {string} column - Its column, named in the message.
@@ -1296,20 +1313,17 @@ async function noteLabels(db) {
 
 /**
  * The language a note's frontmatter says it is in: a language note's own
- * Address, else its `data.language`.
+ * Address, else the note of its language — the code the content index derived
+ * for it where the frontmatter is its record, else its own `data.lang`.
  *
- * @param {object|undefined} frontmatter - The note's authored frontmatter.
- * @param {object} db - From {@link openNotesDatabase}, for its Address context.
+ * @param {object|undefined} frontmatter - The note's frontmatter or record.
+ * @param {object} db - From {@link openNotesDatabase}, for its Address context
+ *   and its language notes.
  * @returns {string|undefined} The language's Address.
  */
 function frontmatterLanguage(frontmatter, db) {
     if (!frontmatter || typeof frontmatter !== "object") return undefined;
     const context = db.addressContext ?? {};
-    const read = (value, type) => {
-        if (typeof value !== "string" || !value) return undefined;
-        const tuple = parseAddress(value, { ...context, system: "note", type }, { declared: true });
-        return tuple.reason ? undefined : renderAddress({ ...tuple, system: "note" });
-    };
     if (
         String(frontmatter.type ?? "").toLowerCase() === "skill" &&
         frontmatter.subType === "language" &&
@@ -1322,7 +1336,8 @@ function frontmatterLanguage(frontmatter, db) {
             type: "skill",
             shortcode: frontmatter.shortcode,
         });
-    return read(frontmatter.data?.language, "skill");
+    const code = frontmatter.lang ?? frontmatter.data?.lang;
+    return typeof code === "string" ? db.languageNotes?.get(code) : undefined;
 }
 
 /** Evaluate scalar SQL calls before synchronous Markdown renderers run. */
@@ -1535,9 +1550,8 @@ async function attachPreparedAnchors(prepared, records, contentBase, parsed, con
 
 /**
  * The language each note of a tree is in, by its file: a language note itself,
- * a culture its `data.language`, its own or one it inherits, and an
- * affiliation the language its glossary resolves to — see
- * {@link module:engine/glossary-language}.
+ * and every other note the note of the language the content index derived for
+ * it — see {@link module:engine/glossary-language}.
  *
  * @param {object[]} records - Content-index records.
  * @param {string} contentBase - Root of the content tree.
@@ -1566,12 +1580,13 @@ function pageLanguages(records, contentBase) {
             .filter((record) => isNoteRecord(record))
             .map((record, i) => [noteFile(contentBase, record), notes[i]]),
     );
+    const languageNotes = languageNotesByCode(byKey.values(), keyOf);
     return (source) => {
         const record = byFile.get(source);
         if (!record) return undefined;
         return glossaryLanguage(undefined, record, {
             keyOf: (value) => (typeof value === "string" && value ? value : undefined),
-            lookup: (key) => byKey.get(key),
+            noteOf: (code) => languageNotes.get(code),
             self: keyOf(record),
         });
     };

package/engine/wikilink-syntax.mjs

@@ -104,6 +104,8 @@ export function parseWikilink(rawInner, literal = "") {
     const attributes =
         suffix.startsWith("{") ? parseExtensionAttributes(suffix.slice(1, -1)) : null;
     if (attributes) attributes.problems.push(...refusedAttributes(attributes.values));
+    if (attributes && Object.hasOwn(attributes.values, "ref"))
+        attributes.problems.push("a wikilink never takes ref; its address is its ref");
     return {
         inner: inner.trim(),
         target,

package/engine/word-citations.mjs

@@ -40,6 +40,7 @@
 import MarkdownIt from "markdown-it";
 
 import { isLanguageRecord, noteAddressOf } from "./word-rows.mjs";
+import { nameFormsOf } from "./name-forms.mjs";
 
 /** The parser marked uses are read with: CommonMark's emphasis and nothing added. */
 const PARSER = new MarkdownIt("commonmark");
@@ -101,7 +102,7 @@ export function markedUses(body) {
 
 /**
  * The names a note carries whole, which cite a word they spell exactly: its
- * full name and aliases, and an affiliation's rank and office titles.
+ * full name and listed forms, and an affiliation's rank and office titles.
  *
  * @param {Record<string, any>} record - An index record.
  * @returns {string[]}
@@ -110,8 +111,7 @@ function namesCarried(record) {
     const out = [];
     const name = isMap(record.name) ? record.name : {};
     if (typeof name.full === "string") out.push(name.full);
-    for (const alias of Array.isArray(name.aliases) ? name.aliases : [])
-        if (typeof alias === "string") out.push(alias);
+    out.push(...nameFormsOf(name));
     const governance = isMap(record.data?.governance) ? record.data.governance : {};
     for (const rank of Array.isArray(governance.ranks) ? governance.ranks : [])
         if (isMap(rank) && typeof rank.title === "string") out.push(rank.title);

package/engine/word-rows.mjs

@@ -36,6 +36,7 @@
 
 import { renderAddress } from "./address.mjs";
 import { glossaryLanguage } from "./glossary-language.mjs";
+import { languageNotesByCode } from "./note-language.mjs";
 import {
     AFFIX_KEYS,
     ZERO_AFFIX,
@@ -368,9 +369,10 @@ export function glossaryRows(records, all = records) {
         const key = noteAddressOf(record);
         if (key && !byAddress.has(key)) byAddress.set(key, record);
     }
+    const languageNotes = languageNotesByCode(byAddress.values(), noteAddressOf);
     const reader = {
         keyOf: (value) => (typeof value === "string" && value ? value : undefined),
-        lookup: (key) => byAddress.get(key),
+        noteOf: (code) => languageNotes.get(code),
     };
     const rows = [];
     for (const record of records) {

package/engine/word-terms.mjs

@@ -489,8 +489,8 @@ export const GLOSSARY_ENTRY_FIELDS = Object.freeze([
         kind: "address",
         shape: "a language skill Address",
         describe:
-            "The language the term is in. Unstated, it is the affiliation's language, its " +
-            "parents', or its culture's, or the culture's own.",
+            "The language the term is in. Unstated, it is the note of the language the " +
+            "note is in, its `data.lang` as the content index derives it.",
     }),
 ]);
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "25.1.3",
+    "version": "25.2.1",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package \u2014 content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",

package/site-theme/static/css/style.css

@@ -93,10 +93,6 @@ body {
   -webkit-font-smoothing: antialiased;
 }
 
-.name {
-  font-weight: 700;
-}
-
 a {
   color: var(--accent);
   text-decoration: none;

package/types/engine/changelog-group.d.mts

@@ -1,18 +1,14 @@
 /**
- * `changelog group`: fold the newest release's changeset blocks together by
- * their bold label, order them, and file an undeclared one last.
+ * `changelog group`: give the newest release its final shape.
  *
- * Every earlier release section is untouched, byte for byte — only the
- * first `## <version>` section's `### <Bump> Changes` bodies are rewritten,
- * each independently (a label groups within its own bump level, never
- * across one). Running this on its own output is a no-op: a release already
- * in label order, with each label merged to one block, groups to itself.
+ * Every earlier release section is untouched, byte for byte. Running this on
+ * its own output is a no-op.
  *
  * @param {string} text - The changelog's full contents.
  * @param {object} [opts]
- * @param {readonly string[]|null} [opts.labels] - `changelog.labels`, in
- *   display order. `null`/absent orders every group by first appearance
- *   instead, lead paragraph first, and files nothing as unknown.
+ * @param {readonly string[]|null} [opts.labels] - the changelog `labels`, in
+ *   display order. `null`/absent orders by first appearance and reports
+ *   nothing as undeclared.
  * @returns {{text: string, findings: Array<{line: number,
  *   severity: "warning", message: string}>}}
  */

package/types/engine/changelog-labels.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Read `labels` from the changelog options in `.changeset/config.json`.
+ *
+ * @param {string} [cwd] - The repository root.
+ * @returns {readonly string[]|null} The labels in display order, or `null`
+ *   when the file, the options or `labels` is absent.
+ * @throws {Error} When `config.json` is not JSON, or `labels` is not an array
+ *   of distinct non-empty strings or names `Miscellaneous`.
+ */
+export function readChangelogLabels(cwd?: string): readonly string[] | null;

package/types/engine/changelog-lint.d.mts

@@ -77,9 +77,9 @@ export function topLevelBlocks(text: string, codeLines: Set<number>, scaffoldLin
  *
  * @param {string} text - The file's full contents, frontmatter included.
  * @param {object} [opts]
- * @param {readonly string[]|null} [opts.labels] - `changelog.labels`, in
- *   display order, or `null`/absent when the repository declares none —
- *   {@link checkUnknownLabels} checks nothing in that case.
+ * @param {readonly string[]|null} [opts.labels] - the changelog `labels`, in
+ *   display order, or `null`/absent when the repository declares none, in
+ *   which case only {@link MISCELLANEOUS} is accepted.
  * @returns {{findings: Array<{line: number, column?: number,
  *   severity: "error"|"warning", message: string}>}}
  */
@@ -98,9 +98,9 @@ export function lintChangesetText(text: string, { labels }?: {
  *
  * @param {string} text - The changelog's full contents.
  * @param {object} [opts]
- * @param {readonly string[]|null} [opts.labels] - `changelog.labels`, in
- *   display order, or `null`/absent when the repository declares none —
- *   {@link checkUnknownLabels} checks nothing in that case.
+ * @param {readonly string[]|null} [opts.labels] - the changelog `labels`, in
+ *   display order, or `null`/absent when the repository declares none, in
+ *   which case only {@link MISCELLANEOUS} is accepted.
  * @returns {{findings: Array<{line?: number, column?: number,
  *   severity: "error"|"warning", message: string}>}}
  */
@@ -135,6 +135,11 @@ export function releaseSectionRange(text: string): {
     start: number;
     end: number;
 } | null;
+/**
+ * The label every repository may use without declaring it, for the changes
+ * that fit no declared label. `changelog group` writes it last.
+ */
+export const MISCELLANEOUS: "Miscellaneous";
 /**
  * The finding one rule reports, before its line is mapped into the caller's
  * file.

package/types/engine/content-index.d.mts

@@ -32,30 +32,30 @@ export function noteAddress(frontmatter: Record<string, any>, contentPackage: st
     canonical: string;
 } | null;
 /**
- * A note's `name.aliases` reduced to printable 7-bit ASCII, in order.
+ * A note's listed name forms reduced to printable 7-bit ASCII, by language.
  *
- * An alias is the name a reader is at least as likely to reach for as the
- * canonical one — `Killer Whale` for an orca, `Ice Bear` for a polar bear,
- * `Ix'balam` for a jaguar — so anything searching or completing over the index
- * has to match them too, and needs the same keyboard-typeable form
- * {@link asciiName} gives the primary name.
+ * A listed form is a name a reader is at least as likely to reach for as the
+ * full one — `Killer Whale` for an orca, a people's own name for the people —
+ * so anything searching or completing over the index has to match them too,
+ * and needs the same keyboard-typeable form {@link asciiName} gives the full
+ * name.
  *
- * Order is the authored order, so a caller can pair an entry with the alias it
- * came from. An alias that is not a non-empty string, or that leaves nothing
- * printable behind, is dropped rather than left as a hole — the array is a set
- * of names to match, and a null in it is not one.
+ * Each language keeps its authored order, so a caller can pair an entry with
+ * the form it came from. A form that leaves nothing printable behind is
+ * dropped rather than left as a hole, and a language left with no form is
+ * left out.
  *
- * @param {unknown} aliases - The note's `name.aliases`; may be absent or null.
- * @returns {Array<string>} Possibly empty, never null: a note with no aliases
- *   has an empty set of them, which is a fact rather than a missing value, and
- *   a consumer iterating it should not have to check first.
+ * @param {unknown} name - The note's `name`; may be absent or null.
+ * @returns {Record<string, string[]>} Possibly empty, never null: a note
+ *   listing no form has an empty map, which a consumer iterating it need not
+ *   check first.
  */
-export function asciiAliases(aliases: unknown): Array<string>;
+export function asciiForms(name: unknown): Record<string, string[]>;
 /**
  * Build one index record from a note's frontmatter and its place in the tree.
  *
  * The frontmatter as authored, plus what the index derives from it: the package
- * it compiles as, its address, ASCII folds of its name and aliases, the anchors
+ * it compiles as, its address, ASCII folds of its name and listed forms, the anchors
  * of its body, its Foundry block, the address of its documentation journal, and
  * where the file sits within the tree.
  *

package/types/engine/diagnostics.d.mts

@@ -130,7 +130,7 @@ export function positionInBody(body: string, offset: number, { bodyLine, bodyCol
  * @param {string} raw - The file's full contents, frontmatter included.
  * @param {string} key - The top-level frontmatter key.
  * @param {string} [value] - When given, prefer the occurrence whose line also
- *   carries this text. A list-valued key (`aliases`) is reported at the entry
+ *   carries this text. A list-valued key (`tags`) is reported at the entry
  *   that is wrong, not at the key that introduces it.
  * @param {object} [options] - Options.
  * @param {boolean} [options.topLevel=false] - Require the key at column 1, so

package/types/engine/first-use.d.mts

@@ -1,5 +1,51 @@
 /**
- * Prepare indexed names once, then check only explicit occurrences without reading files.
+ * A use of a name in a page's prose.
+ *
+ * @typedef {object} NameUse
+ * @property {number} start - Inclusive UTF-16 offset of the use.
+ * @property {number} end - Exclusive UTF-16 offset after it, attributes included.
+ * @property {string} key - What the use is counted under.
+ * @property {boolean} emphasised - It sits inside authored strong text.
+ */
+/**
+ * Every use of a name in a body's prose, in source order.
+ *
+ * @param {string} markdown - A body, as authored or expanded.
+ * @param {NameVocabulary} [vocabulary] - What its addresses are read against.
+ * @returns {NameUse[]} The uses that count toward a first use.
+ */
+export function nameUses(markdown: string, vocabulary?: NameVocabulary): NameUse[];
+/**
+ * Mark the first use of each name in a body's prose as bold.
+ *
+ * Each first use is wrapped in {@link FIRST_USE_OPEN} and
+ * {@link FIRST_USE_CLOSE}, which {@link firstUsePlugin} renders as strong
+ * text. A first use already inside authored strong text is left as it is.
+ *
+ * @param {string} markdown - A body's prose, with its generated sections split
+ *   off and its wikilinks not yet resolved.
+ * @param {NameVocabulary} [vocabulary] - What its addresses are read against.
+ * @returns {string} The same markdown with each first use marked.
+ */
+export function boldFirstUses(markdown: string, vocabulary?: NameVocabulary): string;
+/**
+ * Render the first-use marks {@link boldFirstUses} wrote as strong text.
+ *
+ * A mark in inline text opens or closes a `strong`; a mark anywhere else, as in
+ * raw HTML or code, is dropped, so no mark reaches a reader.
+ *
+ * @param {import("markdown-it")} md - Markdown parser to extend.
+ */
+export function firstUsePlugin(md: typeof import("markdown-it")): void;
+/**
+ * Prepare indexed names once, then check each note's marked names without
+ * reading files.
+ *
+ * One rule, a warning at the occurrence:
+ *
+ * - `unlinked-name`: a `.name` span with no `ref` names an indexed note, which
+ *   a link or a `ref` ties to its note.
+ *
  * @param {{records: readonly object[], index: object,
  *   catalog?: import("./names.mjs").NameCatalog,
  *   parsed?: Map<string, {raw: string, body: string, bodyLine?: number, bodyColumn?: number}>,
@@ -29,3 +75,53 @@ export function createFirstUseChecker({ records, index, parsed, syntax, catalog,
     rules: string[];
     message: string;
 }>;
+/**
+ * Opens a first use in expanded markdown: a Unicode noncharacter, which no
+ * authored text, font or encoding uses.
+ */
+export const FIRST_USE_OPEN: "\uFDD0";
+/** Closes a first use in expanded markdown. */
+export const FIRST_USE_CLOSE: "\uFDD1";
+/**
+ * The addresses a page's names are read against: the tree's types and
+ * packages, and the package an address that names none belongs to.
+ */
+export type NameVocabulary = {
+    /**
+     * - Every type an address may name.
+     */
+    types?: Set<string> | undefined;
+    /**
+     * - Every package an address may name.
+     */
+    packages?: Set<string> | undefined;
+    /**
+     * - Packages with no content index.
+     */
+    noIndexPackages?: Set<string> | undefined;
+    /**
+     * - The package the page belongs to.
+     */
+    contentPackage?: string | undefined;
+};
+/**
+ * A use of a name in a page's prose.
+ */
+export type NameUse = {
+    /**
+     * - Inclusive UTF-16 offset of the use.
+     */
+    start: number;
+    /**
+     * - Exclusive UTF-16 offset after it, attributes included.
+     */
+    end: number;
+    /**
+     * - What the use is counted under.
+     */
+    key: string;
+    /**
+     * - It sits inside authored strong text.
+     */
+    emphasised: boolean;
+};

package/types/engine/frontmatter-lint.d.mts

@@ -54,13 +54,16 @@ export function systemAddressFindings(note: object, { index, schemas, systems }?
  *   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
  *   about those keys.
  * @returns {object[]} Findings, each with a locator where one is obtainable.
  */
-export function lintNote(note: object, { schemas, index, currentDate, vocabulary, packs, emittedArt, addressContext, systems, }: {
+export function lintNote(note: object, { schemas, index, currentDate, vocabulary, packs, emittedArt, addressContext, languages, systems, }: {
     schemas: Record<string, readonly object[]>;
     currentDate?: string | undefined;
     index?: object | undefined;
@@ -71,6 +74,7 @@ export function lintNote(note: object, { schemas, index, currentDate, vocabulary
     } | null) | undefined;
     systems?: Readonly<Record<string, SystemBlockSpec>> | undefined;
     addressContext?: object | undefined;
+    languages?: Iterable<string> | undefined;
     packs?: readonly string[] | undefined;
 }): object[];
 /**
@@ -86,6 +90,8 @@ export function lintNote(note: object, { schemas, index, currentDate, vocabulary
  * @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]
@@ -93,12 +99,13 @@ export function lintNote(note: object, { schemas, index, currentDate, vocabulary
  * @returns {{findings: object[], notes: number}} The findings, and how many
  *   notes were inspected.
  */
-export function lintFrontmatter(index: object, { schemas, vocabulary, packs, emittedArt, references, systems, currentDate }: {
+export function lintFrontmatter(index: object, { schemas, vocabulary, packs, emittedArt, references, systems, currentDate, languages }: {
     schemas: Record<string, readonly object[]>;
     currentDate?: string | undefined;
     vocabulary?: Record<string, object> | undefined;
     references?: boolean | undefined;
     systems?: Readonly<Record<string, SystemBlockSpec>> | undefined;
+    languages?: Iterable<string> | undefined;
     packs?: readonly string[] | undefined;
     emittedArt?: ((type: string) => {
         document: string | null;

package/types/engine/glossary-language.d.mts

@@ -5,10 +5,17 @@
  * @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: object): string | undefined;
 /**
  * The language a glossary entry resolves to.
  *
@@ -19,7 +26,7 @@
  * @returns {string|undefined} The language's Address, or `undefined` where the
  *   chain finds none.
  */
-export function glossaryLanguage(entry: object | undefined, owner: object, { keyOf, lookup, self }: GlossaryLanguageReader): string | undefined;
+export function glossaryLanguage(entry: object | undefined, owner: object, { keyOf, noteOf, self }: GlossaryLanguageReader): string | undefined;
 /**
  * How a caller reads Addresses and finds notes.
  */
@@ -31,10 +38,10 @@ export type GlossaryLanguageReader = {
      */
     keyOf: (value: unknown, type: string) => string | undefined;
     /**
-     * - The note an Address
-     * names, or `undefined` where none is known.
+     * - The Address of a
+     * language code's note, or `undefined` where no note is configured for it.
      */
-    lookup: (key: string) => object | undefined;
+    noteOf: (code: string) => string | undefined;
     /**
      * - The owning note's own Address, for a language.
      */

package/types/engine/homepage.d.mts

@@ -140,9 +140,6 @@ export function homepageTitle(fm: object | null | undefined, config: object): st
  * **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.

package/types/engine/journals.d.mts

@@ -3,9 +3,9 @@
  * code blocks are respected so `# foo` inside ``` or ~~~ blocks doesn't
  * trigger a split. Content before the first H1 (if non-empty) becomes a
  * leading page. Each H1 yields a page whose name is the heading
- * text (with any `{#anchor-id}` suffix stripped out and surfaced as
- * `anchorSlug`). The classes the heading declares come along as `classes`, so
- * a surface that honours one has it without reading the suffix again.
+ * text without inline markup (with any `{#anchor-id}` suffix stripped out and
+ * surfaced as `anchorSlug`). The classes the heading declares come along as
+ * `classes`, so a surface that honours one has it without reading the suffix again.
  *
  * `leadName` names that leading page. A journal note's is "Introduction",
  * because it introduces the pages that follow. An item doc's is the item — a

package/types/engine/literature-notes.d.mts

@@ -1,20 +1,5 @@
 /**
- * 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: object, { index }?: {
-    index?: object;
-}): object[];
-/**
- * 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.
@@ -22,18 +7,8 @@ export function checkLanguageChoice(note: object, { index }?: {
 export function checkLiteratureNote(note: object): object[];
 /** 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: readonly string[];
-/**
- * `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;
 /**
- * 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>}
  */