@heroiclands/package-build 23.12.8 → 23.13.0

package/engine/map-lexicon.mjs

@@ -54,6 +54,7 @@ import { nearest } from "./near-miss.mjs";
 import { FONTS_PACKAGE } from "./script-fonts.mjs";
 import { GENERIC_FAMILIES, applyMap } from "./text-maps.mjs";
 import { isLanguageRecord, noteAddressOf } from "./word-rows.mjs";
+import { derivedForms } from "./word-forms.mjs";
 import { LANGUAGE_SUBTYPE, glossText } from "./word-terms.mjs";
 
 /** The configuration file a language is declared in. */
@@ -103,6 +104,9 @@ function said(names) {
  * @property {readonly LexiconWord[]} words - Its words, in `data.words` order.
  * @property {ReadonlyMap<string, readonly NativeForm[]>} byForm - The native
  *   forms by the word's form, NFC; the first word of a form keeps it.
+ * @property {ReadonlyArray<{form: string, from: LexiconWord}>} derived - The
+ *   forms the language's rules derive from its words, folded, as the mapped-run
+ *   word check accepts them (see {@link module:engine/word-forms.derivedForms}).
  */
 
 /**
@@ -134,21 +138,30 @@ function readNatives(value) {
 function lexiconOf(language, data) {
     const words = [];
     const byForm = new Map();
+    const bySource = new Map();
     for (const word of listOf(data?.words)) {
         if (!isMap(word) || typeof word.form !== "string") continue;
         const natives = readNatives(word.native);
-        words.push(
-            Object.freeze({
-                form: word.form,
-                class: typeof word.class === "string" ? word.class : null,
-                gloss: glossText(word.gloss),
-                natives,
-            }),
-        );
+        const read = Object.freeze({
+            form: word.form,
+            class: typeof word.class === "string" ? word.class : null,
+            gloss: glossText(word.gloss),
+            natives,
+        });
+        words.push(read);
+        bySource.set(word, read);
         const key = word.form.normalize("NFC");
         if (!byForm.has(key)) byForm.set(key, natives);
     }
-    return Object.freeze({ language, words: Object.freeze(words), byForm });
+    const derived = derivedForms(data).map(({ form, word }) =>
+        Object.freeze({ form, from: bySource.get(word) }),
+    );
+    return Object.freeze({
+        language,
+        words: Object.freeze(words),
+        byForm,
+        derived: Object.freeze(derived),
+    });
 }
 
 /**
@@ -442,15 +455,17 @@ export function transliterate(ctx, keys, text) {
 /**
  * Every word of a language's lexicon with its native form under a map: the
  * stated exception, else the rows' spelling, each exactly as the build gives
- * it.
+ * it. With `derived`, the forms the language's rules derive follow the words,
+ * each case folded and naming the word it comes from in `from`, so the list
+ * is what the mapped-run word check accepts of the lexicon.
  *
  * @param {object} ctx - The run context.
- * @param {{lang: string, map: string, font?: string}} keys - The language, the
- *   map and the face.
- * @returns {{entries: Array<{form: string, native: string, exception: boolean, class: string|null, gloss: string|null}>}|{problem: string, about: string}}
- *   The words in `data.words` order, or the problem.
+ * @param {{lang: string, map: string, font?: string, derived?: boolean}} keys -
+ *   The language, the map, the face, and whether to list derived forms.
+ * @returns {{entries: Array<{form: string, native: string, exception: boolean, class: string|null, gloss: string|null, from?: string}>}|{problem: string, about: string}}
+ *   The words in `data.words` order, then any derived forms, or the problem.
  */
-export function lexiconEntries(ctx, { lang, map, font }) {
+export function lexiconEntries(ctx, { lang, map, font, derived = false }) {
     const found = commandMapping(ctx, { map, font, lang });
     if ("problem" in found) return { problem: found.problem, about: found.about };
     const lexicon = ctx.lexicons?.get(lang);
@@ -462,9 +477,13 @@ export function lexiconEntries(ctx, { lang, map, font }) {
                 "in its `note`",
         };
     const { map: textMap, font: face, native } = found.mapping;
-    const mapped = lexicon.words.map((word) =>
-        applyMap(textMap, word.form, { font: face, native }),
-    );
+    const listed = [
+        ...lexicon.words.map((word) => ({ word, form: word.form, from: undefined })),
+        ...(derived ?
+            lexicon.derived.map((one) => ({ word: one.from, form: one.form, from: one.from.form }))
+        :   []),
+    ];
+    const mapped = listed.map((one) => applyMap(textMap, one.form, { font: face, native }));
     const unsound = mapped.flatMap((one) => one.pieces).find((one) => one.uncapitalised);
     if (unsound)
         return {
@@ -477,15 +496,15 @@ export function lexiconEntries(ctx, { lang, map, font }) {
             ),
         };
     return {
-        entries: lexicon.words.map((word, i) => ({
-            form: word.form,
+        entries: listed.map(({ word, form, from }, i) => ({
+            form,
             native: mapped[i].text,
             exception:
-                native?.(word.form) !== undefined ||
-                (word.form.toLowerCase() !== word.form &&
-                    native?.(word.form.toLowerCase()) !== undefined),
+                native?.(form) !== undefined ||
+                (form.toLowerCase() !== form && native?.(form.toLowerCase()) !== undefined),
             class: word.class,
             gloss: word.gloss,
+            ...(from === undefined ? {} : { from }),
         })),
     };
 }

package/engine/names.mjs

@@ -33,6 +33,8 @@ const compare = (a, b) =>
  * @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 {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.
  * @property {string} [destination] - Canonical Address used by a resolved link.
  */
@@ -40,10 +42,18 @@ const compare = (a, b) =>
 /**
  * The prepared name and declared-alias lookup.
  * @typedef {object} NameCatalog
- * @property {(label: string, preferred?: {key: string}) => NameMatch|undefined} recognize - Match a whole visible label.
+ * @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.
  */
 
+/**
+ * What a typed `.name` span says the named thing is. A null type matches any note;
+ * a type matches only notes of that type, and a subtype only notes of that subtype.
+ * @typedef {object} NameKind
+ * @property {string|null} type - Supplied type, or null.
+ * @property {string|null} subType - Supplied subtype, or null.
+ */
+
 /**
  * One captured marked-name occurrence.
  * @typedef {object} MarkedName
@@ -150,10 +160,16 @@ export function createNameCatalog({ records, index }) {
     const names = new Map(),
         byFile = new Map(),
         entries = new Map();
-    const addName = (key, full, aliases = []) => {
-        const entry = entries.get(key) ?? { key, full, indexed: true };
+    const addName = (key, full, aliases, type, subType) => {
+        const entry = entries.get(key) ?? {
+            key,
+            full,
+            indexed: true,
+            type,
+            subType: typeof subType === "string" && subType ? subType : null,
+        };
         entries.set(key, entry);
-        for (const text of [full, ...aliases]) {
+        for (const text of [full, ...(aliases ?? [])]) {
             if (typeof text !== "string" || !text.trim()) continue;
             for (const spelling of nameForms(text)) {
                 if (!names.has(spelling)) names.set(spelling, new Map());
@@ -173,7 +189,13 @@ export function createNameCatalog({ records, index }) {
         const full = record.name?.full;
         if (!parts || parts.type === FOLDER_TYPE || typeof full !== "string") continue;
         const page = canonicalKey(parts.package, "note", parts.type, parts.shortcode);
-        const entry = addName(index.resolve(page) ? page : canonical, full, record.name.aliases);
+        const entry = addName(
+            index.resolve(page) ? page : canonical,
+            full,
+            record.name.aliases,
+            parts.type,
+            record.subType,
+        );
         entries.set(canonical, entry);
         if (index.resolve(page)) entries.set(page, entry);
         if (record.file?.path) byFile.set(record.file.path, entry);
@@ -189,11 +211,16 @@ 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));
+        entries.set(canonical, addName(key, hit.name, hit.aliases, parts.type, hit.subType));
     }
     return {
-        recognize(label, preferred) {
-            const candidates = [...(names.get(normalizeName(label))?.values() ?? [])];
+        recognize(label, preferred, kind) {
+            const candidates = [...(names.get(normalizeName(label))?.values() ?? [])].filter(
+                (entry) =>
+                    !kind?.type ||
+                    (entry.type === kind.type &&
+                        (kind.subType == null || entry.subType === kind.subType)),
+            );
             const target =
                 candidates.find((entry) => entry.key === preferred?.key) ??
                 (candidates.length === 1 ? candidates[0] : undefined);
@@ -268,7 +295,7 @@ export function collectUnwrittenNames({ records, catalog }) {
     const kinds = new Map();
     for (const record of records.filter(isNoteRecord)) {
         for (const occurrence of record.names ?? []) {
-            if (catalog.recognize(occurrence.name)) continue;
+            if (catalog.recognize(occurrence.name, undefined, occurrence)) continue;
             const type = occurrence.type,
                 subType = occurrence.subType,
                 kind = JSON.stringify([type, subType]);

package/engine/note-matter.mjs

@@ -0,0 +1,66 @@
+/*
+ * 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
+ */
+
+/**
+ * **A page's frontmatter, read and written.** Reading splits and parses a note
+ * exactly as the content index does ({@link splitFrontmatter} and `yaml`), so a
+ * value reads the same on the site and in the preview as in a compendium pack.
+ * Writing serializes with `js-yaml`, which quotes every string a YAML 1.1
+ * reader would take for a boolean, a number or a timestamp, so Hugo reads each
+ * value back as the string or number it was.
+ *
+ * @module
+ */
+
+import YAML from "yaml";
+import { dump } from "js-yaml";
+import { splitFrontmatter } from "./diagnostics.mjs";
+
+/**
+ * A page split at its frontmatter.
+ *
+ * @typedef {object} NoteMatter
+ * @property {unknown} data - The parsed frontmatter; an empty map where the
+ *   page has none or the block is empty.
+ * @property {string} content - The body after the closing fence and its line
+ *   break, or the whole text where there is no frontmatter.
+ * @property {string} matter - The YAML source between the fences; empty where
+ *   there is no frontmatter.
+ */
+
+/**
+ * Split a page's frontmatter from its body and parse it.
+ *
+ * @param {string} source - The complete Markdown source.
+ * @returns {NoteMatter} The parsed frontmatter, the body and the YAML source.
+ * @throws {Error} The `yaml` parse error, where the frontmatter is not YAML.
+ */
+export function readMatter(source) {
+    const fence = splitFrontmatter(source);
+    if (!fence) return { data: {}, content: source, matter: "" };
+    return { data: YAML.parse(fence.yaml) ?? {}, content: fence.body, matter: fence.yaml };
+}
+
+/**
+ * A page with `data` as its frontmatter above `content`.
+ *
+ * @param {string} content - The body.
+ * @param {Record<string, unknown>} data - The frontmatter.
+ * @returns {string} The fenced YAML, then the body closed on a line break; the
+ *   body alone where `data` serializes to an empty map.
+ */
+export function writeMatter(content, data) {
+    const yaml = dump(data).trim();
+    const body = content.endsWith("\n") ? content : `${content}\n`;
+    return yaml === "{}" ? body : `---\n${yaml}\n---\n${body}`;
+}

package/engine/pdf-build.mjs

@@ -980,6 +980,7 @@ async function prepareWorld(resolved, { contentBase, findings, resolveReplacemen
         dir,
         dependencies: await cachedDependencies(resolved),
         audience: "public",
+        contentBase,
     });
 
     // Pages, indexed and gated exactly as the site does. A book of a tree whose

package/engine/pdf-render.mjs

@@ -94,7 +94,16 @@ import { spanMarkdownPlugin, scanSpans } from "./content-spans.mjs";
 import { GENERIC_FONTS, renderRuns, scanRuns } from "./content-scripts.mjs";
 import { scanFigures } from "./content-figures.mjs";
 import { BLOCK_CONTAINERS, scanBlocks, BLOCK_NAMES } from "./content-blocks.mjs";
-import { inlineVerse, poetryStanzas, scanPoetry } from "./content-poetry.mjs";
+import {
+    COLUMNS_CLASS,
+    STANZA_BREAK,
+    inlineVerse,
+    lineNumber,
+    rightToLeft,
+    scanVerse,
+    verseColumns,
+    verseStanzas,
+} from "./content-verse.mjs";
 import { matchAllOutsideCode, replaceOutsideCode } from "./code-fences.mjs";
 import { HTML_TAG, htmlMessage } from "./content-html.mjs";
 import { EXPRESSION } from "./markdown-expressions.mjs";
@@ -205,12 +214,12 @@ export function createParser(registry) {
     md.use(spanMarkdownPlugin);
     // Verse is held inside a literal fence. Parse its inline content before
     // footnote_tail collects definitions, using the surrounding note's env.
-    md.core.ruler.after("inline", "poetry_inline", (state) => {
+    md.core.ruler.after("inline", "verse_inline", (state) => {
         for (const token of state.tokens) {
-            if (token.type !== "fence" || !/^poetry(?:\s|$)/.test(token.info?.trim() || ""))
+            if (token.type !== "fence" || !/^verse(?:\s|$)/.test(token.info?.trim() || ""))
                 continue;
             token.meta ??= {};
-            token.meta.poetryStanzas = poetryStanzas(token.content).map((stanza) =>
+            token.meta.verseStanzas = verseStanzas(token.content).map((stanza) =>
                 stanza.map(({ text, level }) => {
                     const children = [];
                     state.md.inline.parse(inlineVerse(text), state.md, state.env, children);
@@ -772,20 +781,24 @@ function renderBlock(tokens, i, out, ctx) {
         }
         case "fence":
         case "code_block": {
-            if (token.type === "fence" && /^poetry(?:\s|$)/.test(token.info?.trim() || "")) {
-                const content = token.meta.poetryStanzas
-                    .map((stanza) =>
-                        stanza
-                            .map(({ children, level }) => {
-                                const verse = renderInline({ children }, ctx);
-                                return `${level ? `#h(${level * 1.25}em)` : ""}${verse}`;
-                            })
-                            .join(" \\\n"),
-                    )
-                    .join("\n\n");
-                const poem = scanPoetry(
-                    `${token.markup}${token.info}\n${token.content}${token.markup}`,
-                ).blocks[0];
+            if (token.type === "fence" && /^verse(?:\s|$)/.test(token.info?.trim() || "")) {
+                const opening = `${token.markup}${token.info}`;
+                const poem = scanVerse(`${opening}\n${token.content}${token.markup}`).blocks[0];
+                const step = Number(poem?.attributes.numstep ?? 0) || 0;
+                const content =
+                    poem?.classes.includes(COLUMNS_CLASS) ?
+                        verseGrid(token, poem, opening, step, ctx)
+                    : step ? numberedVerse(token, step, ctx)
+                    : token.meta.verseStanzas
+                            .map((stanza) =>
+                                stanza
+                                    .map(({ children, level }) => {
+                                        const verse = renderInline({ children }, ctx);
+                                        return `${level ? `#h(${level * 1.25}em)` : ""}${verse}`;
+                                    })
+                                    .join(" \\\n"),
+                            )
+                            .join("\n\n");
                 const anchor = poem?.id ? ` <${sectionLabel(ctx.anchorPrefix, poem.id)}>` : "";
                 out.push(
                     `\n#block(width: 100%)[${scriptWrapped(content, poem?.classes, poem?.attributes)}]${anchor}\n`,
@@ -1251,6 +1264,82 @@ function typstLanguage(tag) {
 /** The classes that set a run in a font: a face's run carries `script`. */
 const FONT_CLASSES = Object.freeze(["script", ...Object.values(GENERIC_FONTS)]);
 
+/** A line number in the book: muted, as on the page. */
+const typstNumber = (number) => (number ? `[#text(fill: luma(45%))[${number}]]` : "[]");
+
+/**
+ * A numbered verse without columns: a grid of each line's number and the
+ * line, with a row of space between stanzas.
+ *
+ * @param {object} token - The verse's fence token.
+ * @param {number} step - Its `numstep`.
+ * @param {object} ctx - Render context.
+ * @returns {string} Typst markup.
+ */
+function numberedVerse(token, step, ctx) {
+    let count = 0;
+    const stanzas = token.meta.verseStanzas.map((stanza) =>
+        stanza
+            .map(({ children, level }) => {
+                const verse = renderInline({ children }, ctx);
+                return `  ${typstNumber(lineNumber(++count, step))}, [${level ? `#h(${level * 1.25}em)` : ""}${verse}],`;
+            })
+            .join("\n"),
+    );
+    return [
+        "#grid(columns: (2.5em, 1fr), column-gutter: 1em, row-gutter: 0.35em,",
+        stanzas.join("\n  grid.cell(colspan: 2)[#v(0.5em)],\n"),
+        ")",
+    ].join("\n");
+}
+
+/**
+ * A verse in columns: a grid with a row per verse line, its number first when
+ * the verse is numbered, then each column's entries stacked, the first in the
+ * normal tone and each later one grey. A part whose text runs right to left
+ * is set right to left inside its cell, and the grid keeps the page's
+ * direction, so the columns stay in order. A `***` line is a row of space
+ * across the grid.
+ *
+ * @param {object} token - The expanded verse's fence token.
+ * @param {object} poem - The verse, from `scanVerse`.
+ * @param {string} opening - Its opening line.
+ * @param {number} step - Its `numstep`.
+ * @param {object} ctx - Render context.
+ * @returns {string} Typst markup.
+ */
+function verseGrid(token, poem, opening, step, ctx) {
+    const counts = verseColumns(poem, opening).map((column) => column.entries.length);
+    const width = counts.length + (step ? 1 : 0);
+    const columns = [...(step ? ["2.5em"] : []), ...counts.map(() => "1fr")];
+    const raw = verseStanzas(token.content);
+    const rows = [];
+    let count = 0;
+    token.meta.verseStanzas.forEach((group, at) => {
+        if (raw[at].length === 1 && STANZA_BREAK.test(raw[at][0].text)) {
+            rows.push(`  grid.cell(colspan: ${width})[#v(0.5em)],`);
+            return;
+        }
+        const parts = group.map(({ children }, k) => {
+            const part = renderInline({ children }, ctx);
+            return rightToLeft(raw[at][k].text) ? `#set text(dir: rtl)\n${part}` : part;
+        });
+        let next = 0;
+        const cells = counts.map((n) => {
+            const stacked = parts.slice(next, (next += n));
+            if (stacked.length === 1) return `[${stacked[0]}]`;
+            return `[#stack(dir: ttb, spacing: 0.3em, ${stacked.map((part, k) => (k ? `[#text(fill: luma(45%))[${part}]]` : `[${part}]`)).join(", ")})]`;
+        });
+        const number = step ? [typstNumber(lineNumber(++count, step))] : [];
+        rows.push(`  ${[...number, ...cells].join(", ")},`);
+    });
+    return [
+        `#grid(columns: (${columns.join(", ")}${columns.length === 1 ? "," : ""}), column-gutter: 1.5em, row-gutter: 0.65em,`,
+        ...rows,
+        ")",
+    ].join("\n");
+}
+
 /**
  * Wrap a block's Typst in its font, its language and its direction.
  *

package/engine/read-stdin.mjs

@@ -0,0 +1,29 @@
+/*
+ * 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
+ */
+
+/**
+ * Reads standard input to its end as UTF-8 text.
+ *
+ * The stream is read asynchronously, so a pipe whose writer is slower than the
+ * reader, or a non-blocking descriptor, delivers the whole input instead of
+ * failing with `EAGAIN`.
+ *
+ * @param {NodeJS.ReadableStream} [stream] The stream to drain; standard input by default.
+ * @returns {Promise<string>} The complete input.
+ */
+export async function readStdin(stream = process.stdin) {
+    stream.setEncoding("utf8");
+    let text = "";
+    for await (const chunk of stream) text += chunk;
+    return text;
+}

package/engine/run-rows.mjs

@@ -12,7 +12,7 @@
  */
 
 /**
- * Spans, divs and poetry fences marked with `lang=`, `font=` or `map=`, projected
+ * Spans, divs and verse fences marked with `lang=`, `font=` or `map=`, projected
  * from own-note index records into the SQL `runs` relation. Every value is a
  * column value and none is a key, so two notes writing one tag in different
  * case are two rows. Documentation records and assets contribute no rows.
@@ -41,7 +41,7 @@ export const RUN_COLUMNS = Object.freeze([
  * One run as an index record carries it.
  *
  * @typedef {object} RecordRun
- * @property {"span"|"block"|"poetry"} kind - The construct.
+ * @property {"span"|"block"|"verse"} kind - The construct.
  * @property {string|null} lang - The language it is set in, as written: its
  *   own `lang=`, else the one the div or fence around it states.
  * @property {string|null} tag - The BCP 47 tag it resolves to, or null.

package/engine/run-words.mjs

@@ -21,16 +21,9 @@
  * - a word of a name in the language note's own `data.register` whose `tongue`
  *   is not `translation`, so a foreign name the run uses is listed there first,
  *   as `other:<tongue>` or under another tag the note declares;
- * - a form one rule the language states derives from a lexicon form:
- *   - the noun plural `data.grammar.plural` gives, or the word's own `plural`;
- *   - a verb's citation form with one ending of `data.grammar.verbs.persons`,
- *     which takes the place of a closing `data.grammar.verbs.replaces` where
- *     the pattern states one (see {@link module:engine/verb-pattern.verbForm});
- *   - a suffix of `data.affixes` that states `replaces`, or its `front` form:
- *     `vowel` takes the place of a closing vowel (a letter whose base is `a`,
- *     `e`, `i`, `o` or `u`), letters take the place of those letters, and a
- *     stem closing otherwise takes the suffix whole. An affix that states no
- *     `replaces` derives nothing.
+ * - a form one rule the language states derives from a lexicon form: a noun
+ *   plural, a verb's present form, a replacing suffix, an agreeing form or a
+ *   participle (see {@link module:engine/word-forms.derivedForms}).
  *
  * A word not accepted whole is split at its hyphens and en dashes, and each
  * part is checked. An apostrophe joins a word, so `k'aralzon` is one word, and
@@ -42,11 +35,9 @@
  * @module
  */
 
-import { pluralOf } from "./dictionary-rows.mjs";
 import { languageRecordsByName } from "./map-lexicon.mjs";
 import { RESERVED_TONGUE } from "./language-terms.mjs";
-import { replaceClosing, verbForm, verbPattern } from "./verb-pattern.mjs";
-import { parseWordClass } from "./word-classes.mjs";
+import { addWords, foldWord, lexiconWords } from "./word-forms.mjs";
 import { WORD } from "./word-pattern.mjs";
 
 /** Whether a value is a plain map. */
@@ -61,104 +52,6 @@ const JOINS = /[–-]/u;
 /** A letter, which a checked word holds at least one of. */
 const LETTER = /\p{L}/u;
 
-/**
- * A word as it is compared: NFC, lowercase, `’` read as `'`.
- *
- * @param {string} word - The word.
- * @returns {string} Its folded form.
- */
-export function foldWord(word) {
-    return word.normalize("NFC").toLowerCase().replace(/’/gu, "'");
-}
-
-/** Whether a character is a vowel: its base letter is a, e, i, o or u. */
-const isVowel = (char) => /^[aeiou]/iu.test(char.normalize("NFD"));
-
-/**
- * Add a text's words to a set, each whole and each part of a compound.
- *
- * @param {Set<string>} set - The set.
- * @param {string} text - A form or a name.
- */
-function addWords(set, text) {
-    for (const [word] of text.matchAll(WORD)) {
-        const folded = foldWord(word);
-        set.add(folded);
-        for (const part of folded.split(JOINS)) if (part) set.add(part);
-    }
-}
-
-/**
- * The form a suffix stating `replaces` makes of a stem.
- *
- * @param {string} stem - The stem, folded.
- * @param {string} suffix - The suffix, folded, with no hyphen.
- * @param {string} replaces - The affix's `replaces`.
- * @returns {string} The derived form.
- */
-function attach(stem, suffix, replaces) {
-    if (replaces === "vowel") {
-        const last = Array.from(stem).at(-1);
-        return last !== undefined && isVowel(last) ?
-                stem.slice(0, -last.length) + suffix
-            :   stem + suffix;
-    }
-    return replaceClosing(stem, suffix, foldWord(replaces));
-}
-
-/**
- * The suffixes a language's affixes state `replaces` for: each `form`, and
- * its `front` form, written `-x`.
- *
- * @param {Record<string, any>} data - The language note's `data`.
- * @returns {Array<{suffix: string, replaces: string}>} The suffixes, folded.
- */
-function replacingSuffixes(data) {
-    const out = [];
-    for (const affix of listOf(data.affixes)) {
-        if (!isMap(affix) || typeof affix.replaces !== "string") continue;
-        for (const written of [affix.form, affix.front]) {
-            if (typeof written !== "string") continue;
-            const form = foldWord(written.trim());
-            if (!/^[-–]/u.test(form) || /[-–]$/u.test(form)) continue;
-            const suffix = form.replace(/^[-–]+/u, "");
-            if (suffix) out.push({ suffix, replaces: affix.replaces });
-        }
-    }
-    return out;
-}
-
-/**
- * The words a language note accepts of its own: its forms, and what its
- * plural rows, verb pattern and replacing suffixes derive from them.
- *
- * @param {Record<string, any>} data - The language note's `data`.
- * @returns {Set<string>} The words, folded.
- */
-export function lexiconWords(data) {
-    const accepted = new Set();
-    const grammar = isMap(data?.grammar) ? data.grammar : undefined;
-    const verbs = verbPattern(grammar?.verbs);
-    const replaces = verbs?.replaces === undefined ? undefined : foldWord(verbs.replaces);
-    const suffixes = replacingSuffixes(data ?? {});
-    for (const word of listOf(data?.words)) {
-        if (!isMap(word) || typeof word.form !== "string") continue;
-        addWords(accepted, word.form);
-        const plural = pluralOf(word, grammar);
-        if (plural) addWords(accepted, plural);
-        if (verbs && parseWordClass(word.class).base === "v")
-            for (const { ending } of verbs.endings)
-                addWords(accepted, verbForm(foldWord(word.form), foldWord(ending), replaces));
-        if (suffixes.length)
-            for (const [stem] of word.form.matchAll(WORD)) {
-                const folded = foldWord(stem);
-                for (const { suffix, replaces } of suffixes)
-                    accepted.add(attach(folded, suffix, replaces));
-            }
-    }
-    return accepted;
-}
-
 /**
  * The words of every name a language note registers under a tongue other than
  * `translation`.

package/engine/site-build.mjs

@@ -57,7 +57,7 @@ import { decodeNoteAddresses, noteAddressContext, encodeAddresses } from "./note
 import fs from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
-import matter from "gray-matter";
+import { readMatter, writeMatter } from "./note-matter.mjs";
 
 import { addressSlug } from "./content-address.mjs";
 import { protectCode } from "./code-fences.mjs";
@@ -166,7 +166,7 @@ function readNote(file, ctx) {
     let source;
     try {
         source = fs.readFileSync(file, "utf8");
-        parsed = matter(source);
+        parsed = readMatter(source);
     } catch {
         return null;
     }
@@ -401,7 +401,7 @@ export function writeHomepages(outRoot, pages, config, { related, records, forei
         resolveArtFields(data, webSrc, artSrc);
         const dest = path.join(outRoot, HOMEPAGE_DESTINATION);
         fs.mkdirSync(path.dirname(dest), { recursive: true });
-        fs.writeFileSync(dest, matter.stringify(page.body, encodeAddresses(data)));
+        fs.writeFileSync(dest, writeMatter(page.body, encodeAddresses(data)));
     }
     return pages.length;
 }
@@ -1133,7 +1133,7 @@ export function renderPages(pages, options) {
         if (write) {
             const dest = path.join(outRoot, pageDestination(page));
             fs.mkdirSync(path.dirname(dest), { recursive: true });
-            fs.writeFileSync(dest, matter.stringify(body, encodeAddresses(data)));
+            fs.writeFileSync(dest, writeMatter(body, encodeAddresses(data)));
         }
         if (outputs) outputs.set(page.file, { markdown: body, frontmatter: data });
         byKind[page.kind] = (byKind[page.kind] ?? 0) + 1;