@heroiclands/package-build 23.2.2 → 23.3.1

package/engine/literature-notes.mjs

@@ -13,13 +13,17 @@
 
 /**
  * A work a people tells, sings or writes: the `literature` lore subType and the
- * three optional facts only such a note may state about itself. Whose work it
- * is, `data.culture`, is a field every lore note but a culture note may state,
+ * optional facts only such a note may state about itself. Whose work it is,
+ * `data.culture`, is a field every lore note but a culture note may state,
  * declared in `culture-choice.mjs`.
  *
+ * `data.language` is shared with the `culture` subType: a work names the
+ * tongue it is composed in, and a culture names the tongue its people speak,
+ * whose name lists `package-build npc new` draws from.
+ *
  * `DataFieldSpec` declares the keys a type accepts, not the subType that may
- * write them, so {@link checkLiteratureNote} scopes these keys to `literature`
- * the way the calendar check scopes its own to `calendar`.
+ * write them, so {@link checkLiteratureNote} scopes these keys to the subTypes
+ * that mean them, the way the calendar check scopes its own to `calendar`.
  *
  * @module
  */
@@ -30,6 +34,9 @@ import { positionOfFrontmatterPath } from "./diagnostics.mjs";
 /** 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 = Object.freeze([LITERATURE_SUBTYPE, "culture"]);
+
 /**
  * Require `data.language` to address a `skill` note whose subType is
  * `language`.
@@ -67,7 +74,27 @@ export function checkLanguageChoice(note, { index } = {}) {
 }
 
 /**
- * The fields only a `literature` note may state. Every one is optional.
+ * `data.language`: the tongue a work is composed in, or the tongue a culture's
+ * people speak. Optional on both.
+ *
+ * @type {object}
+ */
+export const LANGUAGE_FIELD = Object.freeze({
+    name: "language",
+    shape: "an Address",
+    kind: "address",
+    ref: "skill",
+    accepts: Object.freeze(["skill"]),
+    check: checkLanguageChoice,
+    describe:
+        "The tongue the work is composed in, or on a culture note the tongue its people " +
+        "speak, as a language skill note. `package-build npc new` draws a culture's names " +
+        "from its language's `data.names`. A `literature` or `culture` note only.",
+});
+
+/**
+ * The fields only a `literature` note may state, beside the shared
+ * {@link LANGUAGE_FIELD}. Every one is optional.
  *
  * @type {ReadonlyArray<object>}
  */
@@ -90,39 +117,47 @@ export const LITERATURE_FIELDS = Object.freeze([
             "The beings, places, gods and other notes the work concerns, and each " +
             "event it concerns, named as `place-ironfells#sack`.",
     },
-    {
-        name: "language",
-        shape: "an Address",
-        kind: "address",
-        ref: "skill",
-        accepts: ["skill"],
-        check: checkLanguageChoice,
-        describe: "The tongue the work is composed in, as a language skill note.",
-    },
 ]);
 
 const LITERATURE_KEYS = Object.freeze(LITERATURE_FIELDS.map((field) => field.name));
 
 /**
- * Refuse a literature field on a lore note of any other subType.
+ * 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.
  *
  * @param {object} note
- * @returns {object[]} One error per literature key written off `literature`.
+ * @returns {object[]} One error per key written off the subTypes that take it.
  */
 export function checkLiteratureNote(note) {
     const type = String(note?.type ?? note?.fm?.type ?? "").toLowerCase();
     const subType = String(note?.fm?.subType ?? "").toLowerCase();
-    if (type !== "lore" || subType === LITERATURE_SUBTYPE) return [];
+    if (type !== "lore") return [];
     const data = note?.fm?.data;
     if (!data || typeof data !== "object" || Array.isArray(data)) return [];
-    return LITERATURE_KEYS.filter((key) => data[key] !== undefined && data[key] !== null).map(
-        (key) => ({
-            file: note.file,
-            ...positionOfFrontmatterPath(note.raw ?? "", ["data", key], { key: true }),
-            severity: "error",
-            message:
-                `\`data.${key}\` describes a work of literature, and this note's ` +
-                `\`subType\` is not \`literature\``,
-        }),
-    );
+    const stated = (key) => data[key] !== undefined && data[key] !== null;
+    const finding = (key, message) => ({
+        file: note.file,
+        ...positionOfFrontmatterPath(note.raw ?? "", ["data", key], { key: true }),
+        severity: "error",
+        message,
+    });
+    const findings = [];
+    if (subType !== LITERATURE_SUBTYPE)
+        for (const key of LITERATURE_KEYS.filter(stated))
+            findings.push(
+                finding(
+                    key,
+                    `\`data.${key}\` describes a work of literature, and this note's ` +
+                        `\`subType\` is not \`literature\``,
+                ),
+            );
+    if (!LANGUAGE_SUBTYPES.includes(subType) && stated(LANGUAGE_FIELD.name))
+        findings.push(
+            finding(
+                LANGUAGE_FIELD.name,
+                "`data.language` names the tongue of a work of literature or of a culture, " +
+                    "and this note's `subType` is neither `literature` nor `culture`",
+            ),
+        );
+    return findings;
 }

package/engine/note-vocabulary.mjs

@@ -111,7 +111,13 @@ import { checkNoteEvents } from "./note-events.mjs";
 import { AFFILIATION_STANDINGS } from "../sohl/affiliation-standings.mjs";
 import { EVENT_ENTRY } from "./note-event-terms.mjs";
 import { CULTURE_FIELD, checkCultureSubType } from "./culture-choice.mjs";
-import { LITERATURE_FIELDS, checkLiteratureNote } from "./literature-notes.mjs";
+import {
+    checkAppearanceProfile,
+    profileLookKeys,
+    requiredHeightGenders,
+} from "./appearance-profile.mjs";
+import { LANGUAGE_FIELD, LITERATURE_FIELDS, checkLiteratureNote } from "./literature-notes.mjs";
+import { checkLanguageNames, requiredGivenGenders } from "./language-names.mjs";
 import { SOCIAL_TIES, SOCIAL_TIE_TARGET_TYPES } from "./social-tie-terms.mjs";
 import { parseNoteDate } from "./note-dates.mjs";
 import { reckoningContext } from "./reckoning-markers.mjs";
@@ -127,6 +133,7 @@ import { checkCitedPopulations, checkPopulation } from "./populations.mjs";
 // finding an author meets state one list.
 import { MARKET_CLASSES, checkMarket } from "./market-class.mjs";
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+import { checkSettlementTables } from "./settlement-tables.mjs";
 
 /**
  * One `data:` key a note type may carry.
@@ -241,11 +248,166 @@ const NUM = Object.freeze({ shape: "number", kind: "number" });
 /** A string, including the enumerated-value fields the format spells as one. */
 const TEXT = Object.freeze({ shape: "string", kind: "string" });
 
+/**
+ * One word of a closed vocabulary: the value a note writes, the label a reader
+ * sees it by, and what it means.
+ *
+ * @typedef {object} LookWord
+ * @property {string} value - The word as a note writes it.
+ * @property {string} label - The word as a reader sees it.
+ * @property {string} describe - What it means, in one line.
+ */
+
+/** A frozen word list from `[value, label, describe]` rows. */
+function lookWords(rows) {
+    return Object.freeze(
+        rows.map(([value, label, describe]) => Object.freeze({ value, label, describe })),
+    );
+}
+
+/**
+ * The words a being's look is stated in, keyed by the `data:` field that takes
+ * them.
+ *
+ * Each field is closed to its list: any other value, an empty one included, is
+ * a finding at the value naming the words it takes. `appearance.complexion`
+ * takes one word or a list of them, and each entry is checked on its own.
+ * `appearance.extra_features` is not here: it is free text, a list of the marks
+ * no word covers.
+ *
+ * @type {Readonly<Record<string, readonly LookWord[]>>}
+ */
+export const BEING_LOOK_VOCABULARY = Object.freeze({
+    gender: lookWords([
+        ["female", "Female", "Female."],
+        ["male", "Male", "Male."],
+        ["nonbinary", "Nonbinary", "Neither male nor female."],
+        ["none", "None", "The being has no gender, as against one that is simply unrecorded."],
+        ["other", "Other", "A gender none of these words fits."],
+    ]),
+    frame: lookWords([
+        ["scant", "Scant", "Very thin, with little flesh over the bone."],
+        ["light", "Light", "Slender, narrow through shoulder and hip."],
+        ["medium", "Medium", "The ordinary build, neither slight nor heavy."],
+        ["heavy", "Heavy", "Broad and solid, in muscle or in flesh."],
+        ["massive", "Massive", "Exceptionally large in frame."],
+    ]),
+    "appearance.eye_color": lookWords([
+        ["amber", "Amber", "Golden or coppery, with no grey or green in it; the honey-toned eye."],
+        [
+            "black",
+            "Black",
+            "An iris that cannot be told from the pupil in any light, darker than `dark_brown`.",
+        ],
+        ["blue", "Blue", "Unmixed blue, from pale ice to deep sea."],
+        ["brown", "Brown", "Mid-brown, the iris pattern still legible in ordinary light."],
+        ["dark_brown", "Dark Brown", "Brown so deep the iris barely separates from the pupil."],
+        ["grey", "Grey", "Grey or grey-blue, cool and without green."],
+        ["green", "Green", "Green dominant, with no brown ring worth naming."],
+        [
+            "hazel",
+            "Hazel",
+            "Brown and green together, often shifting with the light; the commonest mixed eye.",
+        ],
+        ["violet", "Violet", "The pink-violet of an iris carrying no pigment."],
+    ]),
+    "appearance.hair_color": lookWords([
+        ["auburn", "Auburn", "Red-brown with the red dominant."],
+        ["black", "Black", "True black, with no brown cast in sunlight."],
+        ["blonde", "Blonde", "Light yellow, from near-white to wheat."],
+        ["brown", "Brown", "Mid-brown, neither dark nor reddish."],
+        [
+            "chestnut",
+            "Chestnut",
+            "Mid-brown with a red cast, the brown dominant — between brown and auburn.",
+        ],
+        ["dark_blonde", "Dark Blonde", "Blonde darkened towards light brown."],
+        ["dark_brown", "Dark Brown", "Brown approaching black, still brown in sunlight."],
+        ["grey", "Grey", "Grey throughout, with nothing of the original colour left to read."],
+        ["greying_black", "Greying Black", "Black still dominant, grey coming in."],
+        ["greying_brown", "Greying Brown", "Brown still dominant, grey coming in."],
+        ["red", "Red", "Ginger or copper, the red unmixed with brown."],
+        ["silver", "Silver", "Grey with a bright metallic sheen rather than a dull cast."],
+        [
+            "strawberry_blond",
+            "Strawberry Blond",
+            "Pale red-gold: blonde with a red cast, lighter than red.",
+        ],
+        ["white", "White", "Wholly white, whether from age or from carrying no pigment."],
+    ]),
+    "appearance.skin_color": lookWords([
+        [
+            "pale",
+            "Pale",
+            "The lightest skin, which burns rather than browns; also skin carrying no pigment.",
+        ],
+        ["fair", "Fair", "Light with a pink cast, burning before it browns."],
+        ["light", "Light", "Light and neutral, browning without burning readily."],
+        ["medium", "Medium", "Neither light nor dark, with no strong cast either way."],
+        ["olive", "Olive", "Medium with a green-grey cast."],
+        ["tawny", "Tawny", "Light brown, warm rather than olive."],
+        ["golden", "Golden", "Light to medium with a yellow cast."],
+        ["tanned", "Tanned", "Medium, darkened by sun rather than by birth."],
+        ["swarthy", "Swarthy", "Dark with an olive or sallow cast, between olive and brown."],
+        ["brown", "Brown", "Mid-brown."],
+        [
+            "dark",
+            "Dark",
+            "Darker than brown with no particular cast; the general word where no finer shade is stated.",
+        ],
+        ["dark_brown", "Dark Brown", "Deep brown."],
+        ["ebony", "Ebony", "The darkest skin, near-black."],
+    ]),
+    "appearance.complexion": lookWords([
+        ["ashen", "Ashen", "Grey and drained; the skin of serious illness, shock or terror."],
+        ["blotchy", "Blotchy", "Uneven in colour, patched red or pale."],
+        ["chapped", "Chapped", "Reddened and cracked by cold and wind."],
+        ["clear", "Clear", "Free of blemish, mark or broken vessel."],
+        ["freckled", "Freckled", "Freckled, in patches or across the whole face."],
+        ["jaundiced", "Jaundiced", "Yellowed, the colour a failing liver gives."],
+        ["leathery", "Leathery", "Thickened and toughened by years of exposure."],
+        ["oily", "Oily", "Carrying a greasy sheen."],
+        ["pasty", "Pasty", "Pale and doughy; the skin of indoor work and poor feeding."],
+        ["pimpled", "Pimpled", "Presently broken out, with pimples at brow, cheek or jaw."],
+        ["pockmarked", "Pockmarked", "Pitted by pox, or by deep pimples long since healed."],
+        ["rough", "Rough", "Coarse in texture, without the wear of outdoor work."],
+        ["ruddy", "Ruddy", "High colour at cheek and nose, from weather, drink or constitution."],
+        ["sallow", "Sallow", "Yellowish and bloodless."],
+        [
+            "scabrous",
+            "Scabrous",
+            "Rough and scaling, the skin of a lasting complaint such as eczema.",
+        ],
+        [
+            "scarred",
+            "Scarred",
+            "Marked by healed wounds. `extra_features` says where and from what.",
+        ],
+        ["smooth", "Smooth", "Even in texture, whatever marks it carries."],
+        ["sun_kissed", "Sun-Kissed", "Browned by sun on skin not naturally that dark."],
+        ["sunburnt", "Sunburnt", "Presently burned, red and peeling."],
+        ["translucent", "Translucent", "So pale the vessels show through."],
+        [
+            "vitiligo",
+            "Vitiligo",
+            "Patched with white where the skin has lost its colour, most often at face, hands and mouth. The tone it has lost is still what `skin_color` states.",
+        ],
+        ["wan", "Wan", "Pale and drained; the skin of exhaustion or convalescence."],
+        ["weathered", "Weathered", "Worn and lined by sun and wind; the skin of outdoor work."],
+        ["wrinkled", "Wrinkled", "Deeply lined by age."],
+    ]),
+});
+
+/** The values of one field of {@link BEING_LOOK_VOCABULARY}. */
+function lookValues(field) {
+    return Object.freeze(BEING_LOOK_VOCABULARY[field].map(({ value }) => value));
+}
+
 /** The words a being's `gender` takes. */
-const BEING_GENDERS = Object.freeze(["male", "female", "nonbinary", "none", "other"]);
+const BEING_GENDERS = lookValues("gender");
 
 /** The words a being's `frame` takes, lightest to heaviest. */
-const BEING_FRAMES = Object.freeze(["scant", "light", "medium", "heavy", "massive"]);
+const BEING_FRAMES = lookValues("frame");
 
 /** Words as code spans, joined by commas and a final "or". */
 function wordList(words) {
@@ -253,6 +415,175 @@ function wordList(words) {
     return `${spans.slice(0, -1).join(", ")} or ${spans.at(-1)}`;
 }
 
+/**
+ * A string field closed to one list of {@link BEING_LOOK_VOCABULARY}, its words
+ * named in the reference and their meanings linked.
+ *
+ * @param {string} name - The field, as declared.
+ * @param {string} what - What the field states, without a closing stop.
+ * @returns {object} The declaration.
+ */
+function lookField(name, what) {
+    const allowed = lookValues(name);
+    return {
+        name,
+        ...TEXT,
+        allowed,
+        describe:
+            `${what}: one of ${wordList(allowed)}. ` +
+            "See [a being's look](format-details.md#a-beings-look) for what each word means.",
+    };
+}
+
+/**
+ * A culture's `data.appearanceProfile`: weighted words for each being-look
+ * field but `gender`, and height ranges keyed by gender. Its keys and the words
+ * each takes are read from {@link BEING_LOOK_VOCABULARY}; what a profile means
+ * and how `package-build npc new` draws from it is in `appearance-profile.mjs`.
+ *
+ * @type {DataFieldSpec}
+ */
+const APPEARANCE_PROFILE_FIELD = Object.freeze({
+    name: "appearanceProfile",
+    kind: "map",
+    shape: "an appearance profile",
+    check: (note) => checkAppearanceProfile(note, BEING_LOOK_VOCABULARY),
+    describe:
+        "What this culture's people look like, for `package-build npc new`: " +
+        `${wordList(profileLookKeys(BEING_LOOK_VOCABULARY)).replace(/ or (?!.* or )/, " and ")} ` +
+        "each map words of that field's vocabulary to positive weights, and `height` maps a " +
+        "gender to a `{min, max}` range, " +
+        `${wordList([...requiredHeightGenders()]).replace(" or ", " and ")} required. A culture ` +
+        "note only. See [appearance profiles](format-details.md#appearance-profiles).",
+    fields: Object.freeze([
+        ...profileLookKeys(BEING_LOOK_VOCABULARY).map((key) =>
+            Object.freeze({
+                name: key,
+                kind: "map",
+                shape: "a map of words to weights",
+                required: true,
+                describe: `Weighted \`${key}\` words; a word left out is never drawn.`,
+                values: Object.freeze({
+                    kind: "number",
+                    shape: "a positive weight",
+                    describe: "The word's weight against the others in its map.",
+                }),
+            }),
+        ),
+        Object.freeze({
+            name: "height",
+            kind: "map",
+            shape: "a map of genders to height ranges",
+            required: true,
+            describe:
+                "Height ranges keyed by gender; a gender with no range draws from the span " +
+                "of every range stated.",
+            values: Object.freeze({
+                kind: "map",
+                shape: "a height range",
+                describe: "The shortest and tallest height drawn.",
+                fields: Object.freeze([
+                    Object.freeze({
+                        name: "min",
+                        kind: "string",
+                        required: true,
+                        shape: "a height in metres or feet and inches",
+                        describe: "The shortest height drawn.",
+                    }),
+                    Object.freeze({
+                        name: "max",
+                        kind: "string",
+                        required: true,
+                        shape: "a height in metres or feet and inches",
+                        describe: "The tallest height drawn.",
+                    }),
+                ]),
+            }),
+        }),
+    ]),
+});
+
+/**
+ * A language's `data.names`: the pattern its speakers' names are built by and
+ * the lists each part is drawn from. Its keys beyond `pattern` and `given` are
+ * named by the language, so the map declares no closed inner keys and
+ * {@link checkLanguageNames} checks the whole of it; what the lists mean and
+ * how `package-build npc new` draws from them is in `language-names.mjs`.
+ *
+ * @type {DataFieldSpec}
+ */
+const NAMES_FIELD = Object.freeze({
+    name: "names",
+    kind: "map",
+    shape: "a language's name lists",
+    check: (note) => checkLanguageNames(note, BEING_LOOK_VOCABULARY),
+    describe:
+        "How this language's speakers are named, for `package-build npc new`: `pattern` " +
+        'builds a name from placeholders such as "{given} {clan}" and literal text, `given` ' +
+        "maps a gender to a list of given names, " +
+        `${wordList([...requiredGivenGenders()]).replace(" or ", " and ")} required, and ` +
+        "every other key is a list of names a placeholder of the same name draws from. A " +
+        "language skill note only. See [name lists](format-details.md#name-lists).",
+    fields: Object.freeze([
+        Object.freeze({
+            name: "pattern",
+            kind: "string-list-or-map",
+            required: true,
+            shape: 'a pattern such as "{given} {clan}", a list of them, or a map of genders to either',
+            describe:
+                "How a name is built: each `{list}` placeholder is filled from the list of " +
+                "that name, `{given.<gender>}` from that gender's given names, and the text " +
+                "around them is written as it stands. A list states every form a name may " +
+                "take; a map keyed by gender states each gender's forms, and a gender with " +
+                "none takes every pattern stated.",
+            entries: Object.freeze({
+                kind: "string",
+                shape: "a pattern",
+                describe: "One form a name may take.",
+            }),
+            values: Object.freeze({
+                kind: "string-or-list",
+                shape: "a pattern or a list of them",
+                describe: "The forms a name of that gender may take.",
+                entries: Object.freeze({
+                    kind: "string",
+                    shape: "a pattern",
+                    describe: "One form a name of that gender may take.",
+                }),
+            }),
+        }),
+        Object.freeze({
+            name: "given",
+            kind: "map",
+            required: true,
+            shape: "a map of genders to lists of names",
+            describe:
+                "Given names by gender word. A gender with no list draws from every given " +
+                "list together.",
+            values: Object.freeze({
+                kind: "list",
+                shape: "a list of names",
+                describe: "The given names of one gender.",
+                entries: Object.freeze({
+                    kind: "string",
+                    shape: "a name",
+                    describe: "One name, as written.",
+                }),
+            }),
+        }),
+    ]),
+    values: Object.freeze({
+        kind: "list",
+        shape: "a list of names",
+        describe: "A list a placeholder of the same name draws from, such as `clan` or `family`.",
+        entries: Object.freeze({
+            kind: "string",
+            shape: "a name",
+            describe: "One name, as written.",
+        }),
+    }),
+});
+
 /** A list. */
 const LIST = Object.freeze({ shape: "list", kind: "list" });
 
@@ -643,17 +974,23 @@ const CHARGES = Object.freeze([
 /**
  * Everything `place` asks of a whole note.
  *
- * Two questions about one subject, and they are independent: who governs this
- * inhabited place, and — where the note is a body rather than somewhere within one — what
- * the body states about itself. A type declares one whole-note check, so the
- * two are composed here rather than either being folded into the other.
+ * Three questions about one subject, and they are independent: who governs
+ * this inhabited place, what the body states about itself where the note is a
+ * body rather than somewhere within one, and whether a region's settlements
+ * table agrees with its holding model and the notes it links. A type declares
+ * one whole-note check, so the three are composed here rather than any being
+ * folded into another.
  *
  * @param {object} note - The note.
  * @param {object} [opts] - The lint's options, passed through unchanged.
- * @returns {object[]} Findings from both.
+ * @returns {object[]} Findings from all three.
  */
 function checkPlace(note, opts) {
-    return [...checkGovernment(note), ...checkWorldFacts(note, opts)];
+    return [
+        ...checkGovernment(note),
+        ...checkWorldFacts(note, opts),
+        ...checkSettlementTables(note, opts),
+    ];
 }
 
 /** Validate a being's authored date using the shared note-date grammar. */
@@ -1036,7 +1373,8 @@ export const NOTE_VOCABULARY = Object.freeze({
                 describe:
                     `One of ${wordList(BEING_GENDERS)}. ` +
                     "`none` says the being has no gender; an absent field says its " +
-                    "gender is unrecorded.",
+                    "gender is unrecorded. See [a being's look](format-details.md#a-beings-look) " +
+                    "for what each word means.",
             },
             {
                 name: "species",
@@ -1106,22 +1444,31 @@ export const NOTE_VOCABULARY = Object.freeze({
                 name: "frame",
                 ...TEXT,
                 allowed: BEING_FRAMES,
-                describe: `Relative frame — one of ${wordList(BEING_FRAMES)}.`,
+                describe:
+                    `Relative frame — one of ${wordList(BEING_FRAMES)}. ` +
+                    "See [a being's look](format-details.md#a-beings-look) for what each word means.",
             },
-            { name: "appearance.eye_color", ...TEXT, describe: "Eye colour." },
-            { name: "appearance.hair_color", ...TEXT, describe: "Hair colour." },
-            { name: "appearance.skin_color", ...TEXT, describe: "Skin colour." },
+            lookField("appearance.eye_color", "Eye colour"),
+            lookField("appearance.hair_color", "Hair colour"),
+            lookField("appearance.skin_color", "Skin colour"),
             {
-                name: "appearance.complexion",
+                ...lookField("appearance.complexion", "The skin's condition"),
                 ...TEXT_OR_LIST,
                 describe:
-                    "The skin's condition — one value, or several, because a face " +
-                    "carries more than one at once. A single value means a list of one.",
+                    `The skin's condition: ${wordList(lookValues("appearance.complexion"))}, ` +
+                    "one word or a list of several, because a face carries more than one at " +
+                    "once. A single word means a list of one. See " +
+                    "[a being's look](format-details.md#a-beings-look) for what each word means.",
+                entries: Object.freeze({
+                    kind: "string",
+                    shape: "a string",
+                    allowed: lookValues("appearance.complexion"),
+                }),
             },
             {
                 name: "appearance.extra_features",
                 ...TEXT_LIST,
-                describe: "Anything else a stranger would notice.",
+                describe: "Anything else a stranger would notice, in free text.",
             },
         ]),
     }),
@@ -1467,6 +1814,7 @@ export const NOTE_VOCABULARY = Object.freeze({
                 accepts: ["skill"],
                 describe: "The skill this one specialises.",
             },
+            NAMES_FIELD,
         ]),
     }),
 
@@ -1641,7 +1989,8 @@ export const NOTE_VOCABULARY = Object.freeze({
         // A lore note is prose, and what it *is* about is its subType — with
         // two exceptions. A calendar is a division of the year, and a division
         // is data; a work of literature states in what tongue it is and what it
-        // concerns. The checks scope each family to the subType that means it,
+        // concerns, and a culture what tongue it speaks and what its people look
+        // like. The checks scope each family to the subType that means it,
         // because `DataFieldSpec` declares the keys a type accepts and not the
         // subType that may write them. Any lore note may name the people it
         // belongs to; a culture note names only itself.
@@ -1660,7 +2009,9 @@ export const NOTE_VOCABULARY = Object.freeze({
                     "culture, and states the field only as itself.",
             },
             ...LITERATURE_FIELDS,
+            LANGUAGE_FIELD,
             EVENTS_FIELD,
+            APPEARANCE_PROFILE_FIELD,
         ]),
     }),