@heroiclands/package-build 23.12.8 → 24.0.0

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-rows.mjs

@@ -130,7 +130,7 @@ export const NEAR_NAME_COLUMNS = Object.freeze([...IDENTITY, "near", "given", "m
 /** Every column of the `negation` relation, in order: one row per language. */
 export const NEGATION_COLUMNS = Object.freeze(["language", "particle", "mutation"]);
 /** Every column of the `stress` relation, in order. */
-export const STRESS_COLUMNS = Object.freeze(["language", "stress"]);
+export const STRESS_COLUMNS = Object.freeze(["language", "two", "longer", "mark"]);
 /** Every column of the `finals` relation, in order. */
 export const FINAL_COLUMNS = Object.freeze([...IDENTITY, ...FINAL_KEYS]);
 /** Every column of the `syllables` relation, in order: one row per language. */
@@ -789,7 +789,13 @@ export function stressRows(records) {
     const rows = [];
     for (const [language, record] of languagesOf(records)) {
         const stress = soundsOf(isMap(record.data) ? record.data : {}).stress;
-        if (typeof stress === "string") rows.push({ language, stress });
+        if (isMap(stress))
+            rows.push({
+                language,
+                two: stress.two ?? null,
+                longer: stress.longer ?? null,
+                mark: stress.mark ?? null,
+            });
     }
     return rows;
 }

package/engine/language-terms.mjs

@@ -126,13 +126,21 @@ export const HELD_CLIPS = Object.freeze(["first"]);
 /** How often a group of clusters stands inside a word. */
 export const CLUSTER_USES = Object.freeze(["common", "sparing"]);
 
-/** Where a language's stress falls. */
-export const STRESS_RULES = Object.freeze([
-    "first syllable",
-    "penultimate or final",
-    "by weight",
-    "as marked",
-]);
+/** The syllable a word of two stresses. */
+export const STRESS_TWO = Object.freeze(["first", "last"]);
+
+/** The syllable a word of three or more stresses, counted from its end. */
+export const STRESS_LONGER = Object.freeze(["antepenultimate", "penultimate", "final"]);
+
+/**
+ * The diacritics that mark a stress the rule would not choose, with the
+ * combining character each is written with.
+ */
+export const STRESS_MARKS = Object.freeze({
+    acute: "\u0301",
+    grave: "\u0300",
+    circumflex: "\u0302",
+});
 
 /** Which sounds meet where two parts of a word join. */
 export const JOIN_MEETINGS = Object.freeze(["C+C", "V+C", "V+V"]);
@@ -690,6 +698,39 @@ export const HARMONY_FIELDS = Object.freeze([
     }),
 ]);
 
+/**
+ * The keys of a language's `data.sounds.stress`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const STRESS_FIELDS = Object.freeze([
+    Object.freeze({
+        name: "two",
+        kind: "string",
+        required: true,
+        allowed: STRESS_TWO,
+        shape: `one of ${STRESS_TWO.join(", ")}`,
+        describe: "The stressed syllable of a word of two syllables.",
+    }),
+    Object.freeze({
+        name: "longer",
+        kind: "string",
+        required: true,
+        allowed: STRESS_LONGER,
+        shape: `one of ${STRESS_LONGER.join(", ")}`,
+        describe: "The stressed syllable of a word of three or more, counted from its end.",
+    }),
+    Object.freeze({
+        name: "mark",
+        kind: "string",
+        allowed: Object.freeze(Object.keys(STRESS_MARKS)),
+        shape: `one of ${Object.keys(STRESS_MARKS).join(", ")}`,
+        describe:
+            "The diacritic that marks a stress the rule would not choose; it moves the stress to " +
+            "the syllable it sits on.",
+    }),
+]);
+
 /**
  * The keys of a language's `data.sounds.syllables`: what a syllable may open
  * and close on, and what a word may.
@@ -901,10 +942,10 @@ export const SOUND_FIELDS = Object.freeze([
     }),
     Object.freeze({
         name: "stress",
-        kind: "string",
-        allowed: STRESS_RULES,
-        shape: `one of ${STRESS_RULES.join(", ")}`,
-        describe: "Where a word's stress falls.",
+        kind: "map",
+        shape: "a map — `{ two, longer, mark? }`",
+        fields: STRESS_FIELDS,
+        describe: "Where a word's stress falls, as a rule a program reads.",
     }),
     Object.freeze({
         name: "finals",
@@ -1623,6 +1664,52 @@ export const VERB_PERSON_FIELDS = Object.freeze(
     ),
 );
 
+/**
+ * The endings `data.grammar.native` writes under a logographic map: the noun
+ * plural, then the six persons of the verb pattern.
+ */
+export const WRITTEN_ENDINGS = Object.freeze([
+    "plural",
+    ...VERB_PERSON_FIELDS.map((person) => person.name),
+]);
+
+/** The keys of one `data.grammar.native` entry. */
+const GRAMMAR_NATIVE_FIELDS = Object.freeze([
+    Object.freeze({
+        name: "ending",
+        kind: "string",
+        required: true,
+        allowed: WRITTEN_ENDINGS,
+        shape: `one of ${WRITTEN_ENDINGS.join(", ")}`,
+        describe:
+            "The ending written: `plural` for a noun's plural, or a person of `verbs.persons` " +
+            "for a verb's present form.",
+    }),
+    Object.freeze({
+        name: "map",
+        kind: "string",
+        required: true,
+        shape: "a logographic mapping note's `data.map.name`",
+        describe: "The logographic map the ending is written for.",
+    }),
+    Object.freeze({
+        name: "font",
+        kind: "string",
+        shape: "a face the map lists",
+        describe:
+            "The one face the writing is for; unstated, it is for every face the map lists, " +
+            "and a writing stated for a face wins over it there.",
+    }),
+    Object.freeze({
+        name: "text",
+        kind: "string",
+        required: true,
+        allowEmpty: true,
+        shape: "the ending in the script, as the map's characters; empty writes the stem alone",
+        describe: "The signs written after the stem's writing.",
+    }),
+]);
+
 /** The two alternatives of a supplied optional verb pattern. */
 const VERB_PATTERN_FIELDS = Object.freeze([
     Object.freeze({
@@ -1651,7 +1738,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 +1816,39 @@ 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.",
+    }),
+    Object.freeze({
+        name: "native",
+        kind: "list",
+        shape: "a list of `{ ending, map, font?, text }`",
+        entries: Object.freeze({
+            kind: "map",
+            shape: "a map — `{ ending, map, font?, text }`",
+            fields: GRAMMAR_NATIVE_FIELDS,
+        }),
+        describe:
+            "Under a logographic map, the signs a noun's plural or a verb's present form is " +
+            "written with after its stem's writing, one entry per ending, map and face.",
+    }),
 ]);
 
 /**
@@ -1693,12 +1862,13 @@ 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?, native? }`",
         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, participles and the endings' " +
+            "logographic writings, for dictionary presentation, the mapped-run word check and " +
+            "logographic maps. Only the shape of supplied keys is " +
+            "checked; no word must follow or state a rule. A language skill note only.",
     }),
     listOfMaps(
         "tongues",