@heroiclands/package-build 23.12.8 → 23.13.0

package/engine/dictionary-rows.mjs

@@ -143,12 +143,23 @@ const defines = (entry) => typeof entry.definition === "string" && entry.definit
 export function pluralOf(word, grammar) {
     if (parseWordClass(word.class).base !== "n") return null;
     if (typeof word.plural === "string" && word.plural) return word.plural;
+    return pluralByRule(word.form, grammar);
+}
+
+/**
+ * The plural a language's `data.grammar.plural` rule gives a form: the first
+ * literal ending replacement that fits, whatever the form's class.
+ *
+ * @param {string} form - The form.
+ * @param {Record<string, any>|undefined} grammar - Its language's
+ *   `data.grammar`.
+ * @returns {string|null} The plural, or `null` where no rule fits.
+ */
+export function pluralByRule(form, grammar) {
     for (const rule of Array.isArray(grammar?.plural) ? grammar.plural : []) {
         if (typeof rule?.ending !== "string" || typeof rule.becomes !== "string") continue;
-        if (word.form.endsWith(rule.ending))
-            return (
-                (rule.ending ? word.form.slice(0, -rule.ending.length) : word.form) + rule.becomes
-            );
+        if (form.endsWith(rule.ending))
+            return (rule.ending ? form.slice(0, -rule.ending.length) : form) + rule.becomes;
     }
     return null;
 }

package/engine/field-reference.mjs

@@ -35,7 +35,7 @@
  */
 
 import path from "node:path";
-import matter from "gray-matter";
+import { writeMatter } from "./note-matter.mjs";
 import { formatNoteFrontmatter } from "./note-format.mjs";
 
 import { authoredFields, runtimeOnlyFields } from "./field-spec.mjs";
@@ -422,7 +422,7 @@ export function shortcodeFromBasename(destination) {
  *   {@link shortcodeFromBasename}.
  * @param {Record<string, unknown>} [options.frontmatter] - The consumer's
  *   declared `docs.itemFields.frontmatter`.
- * @returns {Record<string, unknown>} The envelope, ready for `matter.stringify`.
+ * @returns {Record<string, unknown>} The envelope, ready for `writeMatter`.
  */
 export function itemFieldsEnvelope({ title, shortcode, frontmatter }) {
     return deepMerge(
@@ -464,8 +464,8 @@ export function renderItemFieldsPage(body, { title, destination, contentRoot, fr
         shortcode: shortcodeFromBasename(destination),
         frontmatter,
     });
-    const page = matter.stringify(body, envelope);
-    // `matter.stringify` closes the frontmatter fence directly onto the
+    const page = writeMatter(body, envelope);
+    // `writeMatter` closes the frontmatter fence directly onto the
     // body's first line; Prettier's markdown printer requires a blank line
     // between them, so a page written without one fails a consumer's
     // `lint:format` the moment it is committed. Insert it here rather than

package/engine/first-use.mjs

@@ -83,6 +83,14 @@ function readLabel(text, env = {}) {
 }
 const labelText = (text, env) => readLabel(text, env).text;
 
+/** The kind a span's `data-type` supplies; an invalid value is refused by the span check. */
+function spanKind(span) {
+    const value = span.attrs?.find(([key]) => key === "data-type")?.[1];
+    if (typeof value !== "string") return undefined;
+    const [type, subType] = value.split("/");
+    return { type, subType: subType ?? null };
+}
+
 /** Join overlapping source ranges so lookups stay logarithmic. */
 function ranges(values) {
     const out = [];
@@ -119,7 +127,6 @@ function prose(source, capturedNames) {
     const links = [],
         regions = [],
         excluded = [],
-        bold = [],
         html = [];
     const masked = source
         .replace(/!\[\[[^\]\n]+\]\]|\{\{[^}\n]+\}\}/g, (text, start) => {
@@ -142,7 +149,6 @@ function prose(source, capturedNames) {
             excluded.push({ start, end });
         else if (node.type === "html") html.push(node);
         else if (["strong", "emphasis", "delete", "link", "linkReference"].includes(node.type)) {
-            if (node.type === "strong") bold.push({ start, end });
             if (["link", "linkReference"].includes(node.type) && source[start] === "[")
                 links.push({ start, end, labelled: true });
             for (const child of node.children ?? []) inline(child);
@@ -224,18 +230,8 @@ function prose(source, capturedNames) {
     const linked = ranges(authoredLinks);
     const marked = (capturedNames ?? scanSpans(source).names)
         .filter((span) => eligible(span) && !contains(linked, span))
-        .map((span) => ({ ...span, label: span.visible }));
-    const explicit = ranges([...marked, ...authoredLinks]);
-    return {
-        marked,
-        links: authoredLinks,
-        bold: bold
-            .filter((span) => eligible(span) && !overlaps(explicit, span))
-            .map((span) => ({
-                ...span,
-                label: labelText(source.slice(span.start, span.end), env),
-            })),
-    };
+        .map((span) => ({ ...span, label: span.visible, nameKind: spanKind(span) }));
+    return { marked, links: authoredLinks };
 }
 
 /**
@@ -264,7 +260,7 @@ export function createFirstUseChecker({
                     { raw, bodyLine: authored.bodyLine, bodyColumn: authored.bodyColumn },
                 )
             :   undefined;
-        const { marked, links, bold } = prose(raw, capturedNames);
+        const { marked, links } = prose(raw, capturedNames);
         const events = [
             ...marked.map((span) => ({ ...span, kind: "marked" })),
             ...links.map((link) => {
@@ -286,7 +282,10 @@ export function createFirstUseChecker({
         for (const event of [...events].sort(
             (a, b) => a.label.length - b.label.length || a.label.localeCompare(b.label),
         )) {
-            if (recognized(event.label, event.preferred) || unknown.has(normalize(event.label)))
+            if (
+                recognized(event.label, event.preferred, event.nameKind) ||
+                unknown.has(normalize(event.label))
+            )
                 continue;
             const entry = {
                 key: "name:" + normalize(event.label),
@@ -309,7 +308,8 @@ export function createFirstUseChecker({
             fullUsed = new Set();
         for (const event of events.sort((a, b) => a.start - b.start)) {
             const entry =
-                recognized(event.label, event.preferred) ?? unknown.get(normalize(event.label));
+                recognized(event.label, event.preferred, event.nameKind) ??
+                unknown.get(normalize(event.label));
             if (event.kind === "marked" && entry.indexed) {
                 const destinations = (entry.candidates ?? [entry])
                     .map((target) => target.key)
@@ -338,16 +338,6 @@ export function createFirstUseChecker({
             used.add(entry.key);
             if (introduces) fullUsed.add(entry.key);
         }
-        for (const span of bold) {
-            if (typeof span.label !== "string") continue;
-            const entry = recognized(span.label);
-            if (entry)
-                add(
-                    span.start,
-                    "bold-name",
-                    `“${span.label}” matches an indexed name; mark or link this name`,
-                );
-        }
         const lineStarts = [0];
         for (let i = 0; i < raw.length; i++) if (raw[i] === "\n") lineStarts.push(i + 1);
         return [...findings]

package/engine/key-case-collisions.mjs

@@ -0,0 +1,136 @@
+/*
+ * 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
+ */
+
+/**
+ * Keys that differ only in case, found in the content index's records.
+ *
+ * The notes relation is read with `read_json_auto`, which infers one struct
+ * from every record and treats the names of a struct's fields without regard
+ * to case. A map whose keys an author chooses therefore cannot hold `carved`
+ * in one note and `Carved` in another: the relation refuses to load. This
+ * module names each such pair, with the note and the line of both keys, so the
+ * author renames one.
+ *
+ * @module
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { formatDiagnostic, positionInFrontmatter } from "./diagnostics.mjs";
+
+/**
+ * Walk a record, noting every key under its case-folded path.
+ *
+ * @param {unknown} value - The value at `trail`.
+ * @param {string} trail - The case-folded path to it.
+ * @param {object} record - The record being walked.
+ * @param {Map<string, Map<string, Set<object>>>} groups - Case-folded path to
+ *   each spelling found there and the records that use it.
+ */
+function walk(value, trail, record, groups) {
+    if (Array.isArray(value)) {
+        for (const entry of value) walk(entry, trail, record, groups);
+        return;
+    }
+    if (value === null || typeof value !== "object") return;
+    for (const [key, child] of Object.entries(value)) {
+        const at = `${trail}.${key.toLowerCase()}`;
+        let spellings = groups.get(at);
+        if (!spellings) groups.set(at, (spellings = new Map()));
+        let users = spellings.get(key);
+        if (!users) spellings.set(key, (users = new Set()));
+        users.add(record);
+        walk(child, at, record, groups);
+    }
+}
+
+/**
+ * Every key that two records, or one record, spell with different case at the
+ * same path.
+ *
+ * @param {object[]} records - Content-index records.
+ * @returns {Array<{key: string, other: string, record: object, otherRecord: object}>}
+ *   One entry per spelling that collides with another, naming the record that
+ *   uses it and a record that uses the other spelling.
+ */
+export function findKeyCaseCollisions(records) {
+    const groups = new Map();
+    for (const record of records) walk(record, "", record, groups);
+    const found = [];
+    for (const spellings of groups.values()) {
+        if (spellings.size < 2) continue;
+        const keys = [...spellings.keys()].sort();
+        const [first, ...rest] = keys;
+        for (const key of keys) {
+            const other = key === first ? rest[0] : first;
+            found.push({
+                key,
+                other,
+                record: [...spellings.get(key)][0],
+                otherRecord: [...spellings.get(other)][0],
+            });
+        }
+    }
+    return found;
+}
+
+/**
+ * The note a record came from and where a key sits in it.
+ *
+ * @param {object} record - A content-index record.
+ * @param {string} key - The key to find.
+ * @param {string|undefined} contentBase - The directory `record.file.path` is
+ *   relative to.
+ * @returns {{file: string, line?: number, column?: number}} The path relative
+ *   to the working directory, with the position where the key is found.
+ */
+function noteLocation(record, key, contentBase) {
+    const relative = record.file?.path ?? "";
+    const absolute = contentBase ? path.join(contentBase, relative) : undefined;
+    const file = absolute ? path.relative(process.cwd(), absolute) : relative;
+    let position = {};
+    if (absolute) {
+        try {
+            position = positionInFrontmatter(fs.readFileSync(absolute, "utf8"), key, undefined);
+        } catch {
+            position = {};
+        }
+    }
+    return { file, ...position };
+}
+
+/**
+ * The diagnostics for every case collision in the records, one per spelling,
+ * each naming the note and line of the spelling it collides with.
+ *
+ * @param {object[]} records - Content-index records.
+ * @param {object} [options]
+ * @param {string} [options.contentBase] - The directory the records' paths are
+ *   relative to.
+ * @returns {string[]} Formatted `file:line:column: error: message` lines.
+ */
+export function keyCaseCollisionDiagnostics(records, { contentBase } = {}) {
+    return findKeyCaseCollisions(records).map(({ key, other, record, otherRecord }) => {
+        const here = noteLocation(record, key, contentBase);
+        const there = noteLocation(otherRecord, other, contentBase);
+        const where = [there.file, there.line, there.column].filter((part) => part !== undefined);
+        return formatDiagnostic({
+            ...here,
+            severity: "error",
+            message:
+                `\`${key}\` and \`${other}\` name one key: the content index reads keys ` +
+                `without regard to case, so \`${other}\` in ${where.join(":")} must be spelled ` +
+                `the same way`,
+        });
+    });
+}

package/engine/language-data.mjs

@@ -39,7 +39,8 @@
  *   and NFC (see {@link foreignRowFindings});
  * - a sound-change set's name stands once in the note, a step's label once
  *   in its set, and its `from` and `to` name language notes;
- * - a frame's classes are bases of the master word classes;
+ * - a frame's classes, and the classes an affix's `attachesTo` names, are
+ *   bases of the master word classes, each named once;
  * - a calling-name closing states a `form` or `doubled: true`, not both;
  * - a form stands once in `data.older`;
  * - the mutation `data.negation` names is one of `data.sounds.mutations`;
@@ -69,6 +70,7 @@ import {
 } from "./language-terms.mjs";
 import { LANGUAGE_SUBTYPE } from "./word-terms.mjs";
 import { WORD_CLASS_BASES } from "./word-classes.mjs";
+import { nearest } from "./near-miss.mjs";
 
 /** The bases a frame's `class` names. */
 const CLASS_BASES = new Set(WORD_CLASS_BASES.map((item) => item.token));
@@ -117,9 +119,6 @@ export function tongueDeclared(tag, declared) {
 /** The tag families whose rows name a name of another tongue's register. */
 const FOREIGN_FAMILIES = new Set(["other", "exonym"]);
 
-/** How a foreign row that its tongue's register does not bear out is reported. */
-export const FOREIGN_ROW_SEVERITY = "warning";
-
 /** A name as a foreign row is compared: NFC and lowercase. */
 const foldName = (name) => name.normalize("NFC").toLowerCase();
 
@@ -190,7 +189,7 @@ function foreignRowFindings(rows, index, finding) {
             findings.push(
                 finding(
                     ["data", "register", i, "tongue"],
-                    FOREIGN_ROW_SEVERITY,
+                    "error",
                     languages.length ?
                         `the tongue \`${tongue}\` in \`${row.tongue}\` names ${languages.length} ` +
                             `language notes, ${languages.join(" and ")}; the \`data.tongues\` entries ` +
@@ -217,7 +216,7 @@ function foreignRowFindings(rows, index, finding) {
         findings.push(
             finding(
                 ["data", "register", i, "name"],
-                FOREIGN_ROW_SEVERITY,
+                "error",
                 `\`${row.name}\` is registered as \`${row.tongue}\`, but the register of ` +
                     `${title} (${fm.type}-${fm.shortcode}) lists no \`${tongue}\` name ` +
                     `\`${row.name}\`; correct the spelling, or register the name there first`,
@@ -241,6 +240,198 @@ function formEntries(forms) {
     return [];
 }
 
+/** A suggestion clause for a near miss, or nothing. */
+const suggestion = (value, candidates) => {
+    const near = nearest(value, candidates);
+    return near ? `; did you mean \`${near}\`?` : "";
+};
+
+/** A suggestion clause for a word class written out or mistyped, or nothing. */
+const classSuggestion = (value, bases) => {
+    const spelled = WORD_CLASS_BASES.find((base) => base.expansion === value.trim().toLowerCase());
+    return spelled ? `; did you mean \`${spelled.token}\`?` : suggestion(value, bases);
+};
+
+/**
+ * Each entry of a list of strings that repeats an earlier one, as a finding.
+ *
+ * @param {unknown[]} list - The list.
+ * @param {Array<string|number>} path - Where it sits.
+ * @param {string} verb - What the entry does: `names` or `states`.
+ * @param {Function} finding - The note's finding builder.
+ * @returns {object[]} The findings.
+ */
+function repeats(list, path, verb, finding) {
+    const seen = new Set();
+    const out = [];
+    list.forEach((item, i) => {
+        if (typeof item !== "string") return;
+        const key = item.trim();
+        if (seen.has(key))
+            out.push(
+                finding(
+                    [...path, i],
+                    "error",
+                    `\`${label([...path, i])}\` ${verb} \`${key}\` a second time`,
+                ),
+            );
+        seen.add(key);
+    });
+    return out;
+}
+
+/**
+ * Check `data.grammar.agreement` against what it means: classes of the master
+ * list, each once, and at least two distinct endings to agree among.
+ *
+ * @param {unknown} agreement - The authored value.
+ * @param {Function} finding - The note's finding builder.
+ * @returns {object[]} The findings.
+ */
+function checkAgreement(agreement, finding) {
+    if (!isMap(agreement)) return [];
+    const out = [];
+    const at = ["data", "grammar", "agreement"];
+    const bases = WORD_CLASS_BASES.map((base) => base.token);
+    if (Array.isArray(agreement.classes)) {
+        if (!agreement.classes.length)
+            out.push(
+                finding(
+                    [...at, "classes"],
+                    "error",
+                    "`data.grammar.agreement.classes` must name at least one word class",
+                ),
+            );
+        agreement.classes.forEach((item, i) => {
+            if (typeof item !== "string" || bases.includes(item.trim())) return;
+            out.push(
+                finding(
+                    [...at, "classes", i],
+                    "error",
+                    `\`${label([...at, "classes", i])}\` is \`${item}\`, which is not a word class` +
+                        classSuggestion(item, bases),
+                ),
+            );
+        });
+        out.push(...repeats(agreement.classes, [...at, "classes"], "names", finding));
+    }
+    if (Array.isArray(agreement.endings)) {
+        const distinct = new Set(
+            agreement.endings.filter((item) => typeof item === "string").map((item) => item.trim()),
+        );
+        if (distinct.size < 2)
+            out.push(
+                finding(
+                    [...at, "endings"],
+                    "error",
+                    "`data.grammar.agreement.endings` must state at least two endings for a word to agree among",
+                ),
+            );
+        out.push(...repeats(agreement.endings, [...at, "endings"], "states", finding));
+    }
+    return out;
+}
+
+/**
+ * Check each `data.affixes[].attachesTo` against what it means: bases of the
+ * master word classes, each once, and at least one.
+ *
+ * @param {unknown} affixes - The note's `data.affixes`.
+ * @param {Function} finding - The note's finding builder.
+ * @returns {object[]} The findings.
+ */
+function checkAffixClasses(affixes, finding) {
+    const out = [];
+    const bases = WORD_CLASS_BASES.map((base) => base.token);
+    listOf(affixes).forEach((affix, i) => {
+        if (!isMap(affix) || !Array.isArray(affix.attachesTo)) return;
+        const at = ["data", "affixes", i, "attachesTo"];
+        if (!affix.attachesTo.length)
+            out.push(finding(at, "error", `\`${label(at)}\` must name at least one word class`));
+        affix.attachesTo.forEach((item, j) => {
+            if (typeof item !== "string" || bases.includes(item.trim())) return;
+            out.push(
+                finding(
+                    [...at, j],
+                    "error",
+                    `\`${label([...at, j])}\` is \`${item}\`, which is not a word class` +
+                        classSuggestion(item, bases),
+                ),
+            );
+        });
+        out.push(...repeats(affix.attachesTo, at, "names", finding));
+    });
+    return out;
+}
+
+/**
+ * Check `data.grammar.participles` against what it means: root endings with
+ * letters, and affixes that are suffixes the language's `data.affixes` states.
+ *
+ * @param {unknown} participles - The authored value.
+ * @param {unknown} affixes - The note's `data.affixes`.
+ * @param {Function} finding - The note's finding builder.
+ * @returns {object[]} The findings.
+ */
+function checkParticiples(participles, affixes, finding) {
+    if (!isMap(participles)) return [];
+    const out = [];
+    const at = ["data", "grammar", "participles"];
+    if (Array.isArray(participles.root)) {
+        if (!participles.root.length)
+            out.push(
+                finding(
+                    [...at, "root"],
+                    "error",
+                    "`data.grammar.participles.root` must name at least one ending a verb drops to give its root",
+                ),
+            );
+        participles.root.forEach((item, i) => {
+            if (typeof item === "string" && !item.trim())
+                out.push(
+                    finding(
+                        [...at, "root", i],
+                        "error",
+                        `\`${label([...at, "root", i])}\` must name the letters a verb drops to give its root`,
+                    ),
+                );
+        });
+        out.push(...repeats(participles.root, [...at, "root"], "states", finding));
+    }
+    if (Array.isArray(participles.affixes)) {
+        if (!participles.affixes.length)
+            out.push(
+                finding(
+                    [...at, "affixes"],
+                    "error",
+                    "`data.grammar.participles.affixes` must name at least one suffix of `data.affixes`",
+                ),
+            );
+        const stated = listOf(affixes)
+            .filter((affix) => isMap(affix) && typeof affix.form === "string")
+            .map((affix) => affix.form.trim());
+        const suffixes = stated.filter((form) => /^[-–]/u.test(form) && !/[-–]$/u.test(form));
+        participles.affixes.forEach((item, i) => {
+            if (typeof item !== "string") return;
+            const form = item.trim();
+            const where = `\`${label([...at, "affixes", i])}\` is \`${item}\``;
+            if (suffixes.includes(form)) return;
+            out.push(
+                finding(
+                    [...at, "affixes", i],
+                    "error",
+                    stated.includes(form) ?
+                        `${where}, a ${/^[-–]/u.test(form) ? "infix" : "prefix"}; a participle is a suffix on the root`
+                    :   `${where}, which is not a suffix of \`data.affixes\`` +
+                            suggestion(form, suffixes),
+                ),
+            );
+        });
+        out.push(...repeats(participles.affixes, [...at, "affixes"], "names", finding));
+    }
+    return out;
+}
+
 /**
  * Check a `skill` note's language data against what it means.
  *
@@ -345,6 +536,12 @@ export function checkLanguageData(note, { index, types } = {}) {
             );
     }
 
+    findings.push(
+        ...checkAgreement(grammar.agreement, finding),
+        ...checkParticiples(grammar.participles, data.affixes, finding),
+        ...checkAffixClasses(data.affixes, finding),
+    );
+
     /**
      * The note an Address names, or a finding where it names none.
      *

package/engine/language-terms.mjs

@@ -1651,7 +1651,56 @@ const VERB_PATTERN_FIELDS = Object.freeze([
     }),
 ]);
 
-/** The optional, display-only noun and verb patterns of one language. */
+/** The two keys of a language's optional agreement rule. */
+const AGREEMENT_FIELDS = Object.freeze([
+    Object.freeze({
+        name: "classes",
+        kind: "list",
+        required: true,
+        shape: "a list of word class bases, such as `[adj, pron]`",
+        entries: Object.freeze({ kind: "string", shape: "a word class base" }),
+        describe: "The word classes that agree, each a base of the master word classes.",
+    }),
+    Object.freeze({
+        name: "endings",
+        kind: "list",
+        required: true,
+        shape: "a list of at least two literal endings, such as `[os, a, on]`",
+        entries: Object.freeze({ kind: "string", shape: "a literal ending string" }),
+        describe:
+            "The singular endings an agreeing word swaps among, one for each gender; the " +
+            "`plural` rule gives each one's plural. A word closing on none does not agree.",
+    }),
+]);
+
+/** The two keys of a language's optional participle rule. */
+const PARTICIPLE_FIELDS = Object.freeze([
+    Object.freeze({
+        name: "root",
+        kind: "list",
+        required: true,
+        shape: "a list of closing letters, such as `[athen, ethen]`",
+        entries: Object.freeze({ kind: "string", shape: "the closing letters of a citation form" }),
+        describe:
+            "The infinitive endings a verb's citation form drops to give its root, the longest " +
+            "that matches first. A verb closing on none has no participle.",
+    }),
+    Object.freeze({
+        name: "affixes",
+        kind: "list",
+        required: true,
+        shape: "a list of suffixes of `data.affixes`, such as `[-andar, -thos]`",
+        entries: Object.freeze({
+            kind: "string",
+            shape: "the `form` of a suffix of `data.affixes`",
+        }),
+        describe:
+            "The participle suffixes, each attaching to the root as its own `replaces` says: " +
+            "`vowel` or letters take the place of the root's close, and none adds it whole.",
+    }),
+]);
+
+/** The optional noun, verb, agreement and participle patterns of one language. */
 const GRAMMAR_FIELDS = Object.freeze([
     innerList(
         "plural",
@@ -1680,6 +1729,26 @@ const GRAMMAR_FIELDS = Object.freeze([
         fields: VERB_PATTERN_FIELDS,
         describe: "One optional regular present pattern, printed once at the dictionary head.",
     }),
+    Object.freeze({
+        name: "agreement",
+        kind: "map",
+        shape: "a map — `{ classes, endings }`",
+        fields: AGREEMENT_FIELDS,
+        describe:
+            "How words of the named classes agree with a noun: a word closing on one of the " +
+            "`endings` also takes each other one, and each form takes the `plural` rule. Read " +
+            "by the mapped-run word check.",
+    }),
+    Object.freeze({
+        name: "participles",
+        kind: "map",
+        shape: "a map — `{ root, affixes }`",
+        fields: PARTICIPLE_FIELDS,
+        describe:
+            "Participles on the verb root: a verb closing on a `root` ending drops it, and each " +
+            "named suffix attaches to what is left; a participle closing on an `agreement` " +
+            "ending agrees. Read by the mapped-run word check.",
+    }),
 ]);
 
 /**
@@ -1693,12 +1762,12 @@ export const LANGUAGE_DATA_FIELDS = Object.freeze([
     Object.freeze({
         name: "grammar",
         kind: "map",
-        shape: "a map — `{ plural?, verbs? }`",
+        shape: "a map — `{ plural?, verbs?, agreement?, participles? }`",
         fields: GRAMMAR_FIELDS,
         describe:
-            "Optional noun plurals and one verb pattern for dictionary presentation. Only the " +
-            "shape of supplied keys is checked; no word must follow or state a rule. A language " +
-            "skill note only.",
+            "Optional noun plurals, one verb pattern, agreement and participles, for dictionary " +
+            "presentation and the mapped-run word check. Only the shape of supplied keys is " +
+            "checked; no word must follow or state a rule. A language skill note only.",
     }),
     listOfMaps(
         "tongues",