@heroiclands/package-build 23.3.1 → 23.3.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @heroiclands/package-build
 
+## 23.3.2
+
+### Patch Changes
+
+- Cultures can inherit their language and appearance from parent cultures when generating characters.
+
 ## 23.3.1
 
 ### Patch Changes

package/bin/content-commands.mjs

@@ -141,6 +141,7 @@ import { profileFindings } from "../engine/appearance-profile.mjs";
 import { namesFindings } from "../engine/language-names.mjs";
 import { parseAddress, renderAddress } from "../engine/address.mjs";
 import { cultureKey, generateNpc, npcDefaults, npcSpecProblems } from "../engine/npc-generate.mjs";
+import { cultureFieldSource, cultureHierarchyProblems } from "../engine/culture-parents.mjs";
 
 /**
  * The packs `unpack` extracts.
@@ -2613,11 +2614,12 @@ function newNpc(config, argv) {
         throw new Error(`${argv.out} already exists, and \`npc new\` never overwrites a note`);
 
     const root = config.paths.content;
+    const corpusProblems = [];
     const records = indexRecordsFor({
         contentBase: root,
         config,
         skipDirectories: config.skipDirectories,
-        problems: [],
+        problems: corpusProblems,
     });
     const index = buildLinkIndex(root, {
         config,
@@ -2643,6 +2645,12 @@ function newNpc(config, argv) {
             `\`data.culture\` ${JSON.stringify(written)} is not a culture: it names a ` +
                 `${culture.type ?? hit.type ?? "note"} of subType ${culture.subType ?? "none"}`,
         );
+    const hierarchyProblems = cultureHierarchyProblems(records, key);
+    for (const problem of hierarchyProblems) emitDiagnostic(problem);
+    if (hierarchyProblems.some((problem) => problem.severity === "error")) {
+        process.exitCode = 1;
+        return;
+    }
     const cultureNote = located(hit);
     const profile = culture.data?.appearanceProfile;
     if (profile === undefined || profile === null)
@@ -2652,8 +2660,13 @@ function newNpc(config, argv) {
             `${key} states no \`data.appearanceProfile\`, so \`npc new\` cannot draw its ` +
                 "people's look",
         );
+    const profileSource = cultureFieldSource(records, key, "appearanceProfile") ?? hit;
     const profileErrors = profileFindings(
-        { file: cultureNote.file, raw: hit.raw, fm: culture },
+        {
+            file: located(profileSource).file,
+            raw: profileSource.raw,
+            fm: profileSource.fm ?? profileSource,
+        },
         BEING_LOOK_VOCABULARY,
     );
     if (profileErrors.length) {
@@ -2669,6 +2682,8 @@ function newNpc(config, argv) {
             `${key} states no \`data.language\`, so \`npc new\` has no name lists to draw ` +
                 "from; name the language skill note its people speak",
         );
+    const languageSource = cultureFieldSource(records, key, "language") ?? hit;
+    const languageSourceNote = located(languageSource);
     const tuple = parseAddress(tongue, {
         package: index.contentPackage,
         system: "note",
@@ -2680,14 +2695,14 @@ function newNpc(config, argv) {
     const languageHit = languageKey ? index.addressHit(languageKey) : undefined;
     if (!languageHit)
         throw noteError(
-            cultureNote,
+            languageSourceNote,
             ["data", "language"],
             `${key}'s \`data.language\` names no note in this package or its dependencies`,
         );
     const language = languageHit.fm ?? languageHit;
     if (String(language.type ?? languageHit.type) !== "skill" || language.subType !== "language")
         throw noteError(
-            cultureNote,
+            languageSourceNote,
             ["data", "language"],
             `${key}'s \`data.language\` ${languageKey} is not a language: it names a ` +
                 `${language.type ?? languageHit.type ?? "note"} of subType ` +

package/docs/commands.md

@@ -2828,6 +2828,14 @@ culture missing either, with an error at the culture note:
   `data.names` is an error at the language note. See
   [name lists](reference/format-details.md#name-lists).
 
+The content-index JSONL resolves a culture's `data.language` and
+`data.appearanceProfile` before this command reads them. A child culture may
+inherit each omitted field from its `data.parents`, while a stated value keeps
+precedence. The command consumes the resolved values and keeps the selected
+child culture on the generated note. A parent cycle or conflicting inherited
+sources are errors; complete fields on the selected culture do not excuse a
+cycle. See [culture parents](reference/format-details.md#culture-parents-and-inherited-fields).
+
 A profile or name lists with problems are refused with a finding at each.
 
 A spec that states `name.full` keeps it, and the name must fit the language's

package/docs/content-format.md

@@ -96,6 +96,13 @@ A being states its gender, frame and appearance in words from one closed vocabul
 
 A culture note may state what its people look like in `data.appearanceProfile`: weighted words for frame, eyes, hair, skin and complexion, and height ranges by gender, all from the same vocabulary. A culture names its tongue in `data.language`, and that language skill note may state `data.names`: the patterns its speakers' names are built by and the lists each part is drawn from. `package-build npc new` writes a complete npc note from a spec of a culture and a gender, drawing the name from those lists and everything else the spec leaves out from the profile. See [appearance profiles](reference/format-details.md#appearance-profiles), [name lists](reference/format-details.md#name-lists) and [the command](commands.md#package-build-npc-new).
 
+A culture may name its larger cultures in `data.parents`. Each entry names a
+culture lore note. Omitted `data.language` and `data.appearanceProfile` fields
+inherit independently through those parents; the content-index JSONL contains
+the resolved values, which `npc new` reads directly. A stated field wins over
+its inherited value. See [culture parents](reference/format-details.md#culture-parents-and-inherited-fields)
+for a complete example, parent ordering and findings.
+
 Places, affiliations, lore and beings may name their culture in `data.culture`, and a `doc` of `subType: settingguide` must. A place or affiliation that names none inherits the culture of its parents. See [culture in the index](reference/format-details.md#culture-in-the-index).
 
 Blockquote alerts use `[!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]`, or `[!]`, with optional attributes after the marker. They replace the former info and warn div fences; secret blocks remain supported. See [alerts](authoring/links-and-markup.md#alerts).

package/docs/reference/format-details.md

@@ -2715,6 +2715,104 @@ table would otherwise need: the authored `ORDER BY` decides the section order to
 **Beware `packFolder`.** It is a note's _pack_ folder, not its directory — the
 directory is `file.folder`.
 
+##### Culture parents and inherited fields
+
+A `lore` note of `subType: culture` may list the larger cultures it belongs to
+in `data.parents`. Each entry is an Address naming another culture lore note;
+a missing target, a target of another type or subtype, and a parent cycle are
+errors at the offending list entry. No other lore subtype accepts the key.
+
+A culture inherits `data.language` and `data.appearanceProfile` independently
+when it leaves either field out. A stated value wins for that field. The
+profile is inherited as one complete object; its weights and ranges are not
+merged with another profile. Parents are searched in listed order, depth-first:
+the first parent's chain is searched before the next parent's chain. Sources
+at the same depth that disagree on a field produce a finding. Nothing is
+inherited through a broken parent address.
+
+The emitted content-index JSONL carries the resolved fields in the child's
+`data`, exactly as if the child had stated them. `package-build npc new` and
+other consumers read those resolved values; they do not walk culture parents.
+The child's `data.culture` remains its own Address. A being, place or
+affiliation naming the parent in `data.culture` belongs to that named culture;
+it does not match the parent's children.
+
+These complete notes give Riverfolk their parent culture's tongue and profile:
+
+```markdown
+---
+shortcode: reedfolk
+name: { full: Reedfolk }
+type: lore
+subType: culture
+data:
+  language: skill-reedtongue
+  appearanceProfile:
+    frame: { medium: 1 }
+    eye_color: { brown: 1 }
+    hair_color: { black: 1 }
+    skin_color: { tawny: 1 }
+    complexion: { clear: 1 }
+    height:
+      female: { min: 1.5m, max: 1.7m }
+      male: { min: 1.6m, max: 1.8m }
+---
+
+Reedfolk share the reed tongue and live along the marsh's waterways. Their
+settlements trade by boat, hold seasonal gatherings and pass their stories
+between families at those gatherings.
+```
+
+```markdown
+---
+shortcode: riverfolk
+name: { full: Riverfolk }
+type: lore
+subType: culture
+data:
+  parents: [lore-reedfolk]
+---
+
+Riverfolk belong to the Reedfolk culture and share its tongue. They live
+beside the river's deep channels, where their boats carry grain, timber and
+woven reeds between settlements.
+```
+
+The parent names this language note, whose lists supply generated names:
+
+```markdown
+---
+shortcode: reedtongue
+name: { full: Reed Tongue }
+type: skill
+subType: language
+data:
+  pack: skills
+  names:
+    pattern: "{given} {kin}"
+    given:
+      female: [Nara]
+      male: [Taro]
+    kin: [Mori]
+---
+
+The reed tongue is spoken beside the marsh's waterways. Its speakers use a
+given name followed by a family name, and carry those names between river
+settlements with their trade.
+```
+
+In a package named `reedflats`, the Riverfolk index record carries the Reedfolk
+profile and `data.language` as a published Address object:
+
+```json
+{ "address": "reedflats-note-skill-reedtongue", "anchor": null, "anchorKind": null }
+```
+
+Adding `language: skill-rivertongue` to Riverfolk's `data` selects that language
+instead while retaining the inherited profile, provided the named language
+note exists. Stating an `appearanceProfile` there replaces the inherited
+profile while leaving the inherited tongue in place.
+
 ##### Culture in the index
 
 `data.culture` in the index is the note's **resolved** culture, which is its
@@ -3737,8 +3835,9 @@ missing key, a missing `female` or `male` range, a height that does not read,
 a range whose `min` is above its `max`, and a `height` key that is not a
 gender.
 
-`package-build npc new` refuses a culture that states no profile, naming the
-culture note.
+`package-build npc new` refuses a culture with no resolved profile, naming the
+culture note. A culture may obtain the complete profile from its
+[parents](#culture-parents-and-inherited-fields).
 
 #### Name lists
 
@@ -5006,13 +5105,18 @@ data:
 The saga lists under **In song and story** on `place-ironfells`, which holds the
 sack, on `place-east` and on `lore-fords`.
 
-Calendar fields are written only on a `calendar` note, and `form`, `subjects` and `language`
-only on a `literature` note; written on any other lore subType, each is an error at its own key.
+Calendar fields are written only on a `calendar` note, `form` and `subjects`
+only on a `literature` note, `language` only on `literature` and `culture`, and
+`parents` only on `culture`. Written on any other lore subtype, each is an
+error at its own key.
 `culture` may be written on any lore subType. A culture note is itself the culture, so it
 leaves the field out or names itself, by its shortcode or by any longer form of its Address;
 naming any other note is an error at the value. A `lore` note that states no culture has
-none, since a `lore` note has no `data.parents` to inherit through; a culture note reads as
-its own Address in the index. See [Culture in the index](#culture-in-the-index).
+none; a culture note reads as its own Address in the index, including when it
+names parent cultures. Culture parents supply language and appearance fields,
+not a different cultural identity. See
+[Culture parents](#culture-parents-and-inherited-fields) and
+[Culture in the index](#culture-in-the-index).
 
 | `data` property                       | Values                                                                        | Description                                                                                                                                                                                                                                  |
 | ------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -5046,6 +5150,7 @@ its own Address in the index. See [Culture in the index](#culture-in-the-index).
 | `culture`                             | `Address`                                                                     | The people this lore belongs to — for a `literature` note, the people whose work it is — naming a lore note with `subType: culture`; not on a `culture` note                                                                                 |
 | `form`                                | `string`                                                                      | `literature` only: the kind of work in its people's own terms — `epic`, `saga`, `praise-song`, `elegy`. Free text                                                                                                                            |
 | `subjects`                            | `Address[]`                                                                   | `literature` only: the beings, places, gods and other notes the work concerns, and any event, as `note#id`                                                                                                                                   |
+| `parents`                             | `Address[]`                                                                   | `culture` only: the larger cultures this one belongs to; each target is a culture lore note — see [culture parents](#culture-parents-and-inherited-fields)                                                                                   |
 | `language`                            | `Address`                                                                     | `literature` and `culture` only: the tongue a work is composed in, or a culture's people speak, naming a skill note with `subType: language`; `package-build npc new` draws a culture's names from that language's [name lists](#name-lists) |
 | `events`                              | event entries — see [Events](#events)                                         | What happened to or at this subject: dated, attributed events                                                                                                                                                                                |
 | `appearanceProfile`                   | `{ frame, eye_color, hair_color, skin_color, complexion, height }`            | `culture` only: what its people look like, for `package-build npc new` — see [appearance profiles](#appearance-profiles)                                                                                                                     |

package/docs/reference/note-types.md

@@ -533,6 +533,7 @@ Lore records in-world knowledge. A `culture` describes a people; a `custom` desc
 | `data.namedDays`         | list of `{ name, abbreviation?, day }`                                              | Names assigned to particular days of the year.                                                                                                                                                                                                                                                                                                                               |
 | `data.eras`              | list of `{ shortcode, name, marker?, abbreviation?, proclaimedBy?, start, label? }` | The year-counts kept in this calendar. A marker names one era and uses these months.                                                                                                                                                                                                                                                                                         |
 | `data.formats`           | map of named Calendaria format strings                                              | Named patterns for reading and writing this calendar's dates.                                                                                                                                                                                                                                                                                                                |
+| `data.parents`           | list of Addresses                                                                   | Culture only: parent culture lore notes, searched in listed depth-first order for omitted language and appearance profile fields.                                                                                                                                                                                                                                            |
 | `data.culture`           | an Address                                                                          | The people this lore belongs to — for a work of literature, the people whose work it is — as a culture lore note. A culture note is its own culture, and states the field only as itself.                                                                                                                                                                                    |
 | `data.form`              | string                                                                              | The kind of work in its people's own terms — an epic, a saga, a praise-song, an elegy. Free text.                                                                                                                                                                                                                                                                            |
 | `data.subjects`          | list of Addresses                                                                   | The beings, places, gods and other notes the work concerns, and each event it concerns, named as `place-ironfells#sack`.                                                                                                                                                                                                                                                     |

package/engine/content-format.yaml

@@ -247,6 +247,7 @@ types:
         subTypes: []
     lore:
         data:
+            - parents
             - epoch
             - months
             - weekdays

package/engine/content-index.mjs

@@ -86,6 +86,7 @@
  */
 
 import { isAddressSegment } from "./address-charset.mjs";
+import { cultureInheritance, reportCultureParents } from "./culture-parents.mjs";
 import {
     formatDiagnostic,
     locateFrontmatterKey,
@@ -1178,6 +1179,27 @@ export function collectContentIndex(
     // is found by its canonical address. Before the sort, which reads nothing
     // the pass writes.
     resolveCultures(records, { contentPackage, contentBase, foreignRecord, problems });
+    const cultureNotes = records
+        .filter((record) => isNoteRecord(record) && record.type === "lore")
+        .map((record) => ({
+            fm: record,
+            file: noteFile(contentBase, record),
+            raw: fs.readFileSync(noteFile(contentBase, record), "utf8"),
+        }));
+    const cultureByKey = new Map(
+        cultureNotes.map((note) => [
+            canonicalKey(contentPackage, "note", "lore", note.fm.shortcode),
+            note,
+        ]),
+    );
+    const inheritance = cultureInheritance({
+        contentPackage,
+        notes: cultureNotes,
+        addressHit: (key) => cultureByKey.get(key) ?? foreignRecord?.(key),
+    });
+    reportCultureParents(inheritance.findings, problems);
+    for (const [note, inherited] of inheritance.values)
+        if (Object.keys(inherited).length) note.fm.data = { ...note.fm.data, ...inherited };
 
     // Sorted at every depth like a note's record, and for the same reason: the
     // declaration order of the `asset` fields is a fact about the emitter, not

package/engine/content-links.mjs

@@ -55,6 +55,7 @@
 import { readWikilink } from "./wikilink-syntax.mjs";
 import { encodeAddresses } from "./address-values.mjs";
 import fs from "node:fs";
+import { cultureRecordProblems, cultureInheritedFields } from "./culture-parents.mjs";
 import path from "node:path";
 
 import { matchAllOutsideCode } from "./code-fences.mjs";
@@ -224,6 +225,14 @@ export function buildLinkIndex(
         const body = raw.replace(/^---\n[\s\S]*?\n---\n?/, "");
         const type = record.type.toLowerCase();
         const note = { file: absPath, rel, fm, body, raw, type };
+        const hierarchyProblems = cultureRecordProblems(record);
+        note.inheritedCultureFields = cultureInheritedFields(record);
+        if (hierarchyProblems)
+            note.reportedCultureParents = new Set(
+                hierarchyProblems
+                    .filter((problem) => problem.file === absPath)
+                    .map((problem) => problem.parentIndex),
+            );
 
         for (const hit of frontmatterWikilinks(fm)) {
             frontmatterLinks.push({ note, ...hit });

package/engine/culture-parents.mjs

@@ -0,0 +1,301 @@
+/*
+ * 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
+ */
+
+import { isDeepStrictEqual } from "node:util";
+import { canonicalKey, parseAddress, renderAddress } from "./address.mjs";
+import { positionOfFrontmatterPath, formatDiagnostic } from "./diagnostics.mjs";
+
+const fields = ["language", "appearanceProfile"];
+const payload = (note) => note.fm ?? note;
+const dataOf = (note) => payload(note).data ?? payload(note);
+const culture = (note) => payload(note).type === "lore" && payload(note).subType === "culture";
+const parentsOf = (note) => (Array.isArray(dataOf(note).parents) ? dataOf(note).parents : []);
+
+/** Read a culture parent against the field's Address defaults. */
+function address(value, index) {
+    const tuple = parseAddress(value, {
+        package: index.contentPackage,
+        system: "note",
+        type: "lore",
+        types: index.types,
+        packages: index.packages,
+    });
+    return tuple.reason ? undefined : tuple;
+}
+
+/** The authored edge graph, with every cyclic edge identified. */
+function graph(index) {
+    const out = new Map();
+    const queue = [...(index.notes ?? [])].filter(culture);
+    while (queue.length) {
+        const note = queue.pop();
+        if (out.has(note)) continue;
+        const edges = [];
+        out.set(note, edges);
+        parentsOf(note).forEach((value, position) => {
+            const tuple = address(value, index);
+            if (!tuple || tuple.type !== "lore") return;
+            const target = index.addressHit?.(renderAddress(tuple));
+            if (!target || !culture(target)) return;
+            edges.push({ target, position });
+            queue.push(target);
+        });
+    }
+    const reaches = (start, end) => {
+        const seen = new Set();
+        const queue = [start];
+        while (queue.length) {
+            const current = queue.pop();
+            if (current === end) return true;
+            if (seen.has(current)) continue;
+            seen.add(current);
+            queue.push(...(out.get(current) ?? []).map((edge) => edge.target));
+        }
+        return false;
+    };
+    const cyclic = new Map();
+    for (const [note, edges] of out)
+        cyclic.set(
+            note,
+            new Set(
+                edges.filter((edge) => reaches(edge.target, note)).map((edge) => edge.position),
+            ),
+        );
+    return { out, cyclic };
+}
+
+/** A located hierarchy finding with the Address of the culture it concerns. */
+function finding(note, index, path, message) {
+    const fm = payload(note);
+    return {
+        file: note.file,
+        ...positionOfFrontmatterPath(note.raw ?? "", ["data", "parents", ...path]),
+        severity: "error",
+        code: "culture-parents",
+        cultureAddress: canonicalKey(index.contentPackage, "note", "lore", fm.shortcode),
+        parentIndex: path[0],
+        message,
+    };
+}
+
+/** Validate subtype scope and culture targets; unresolved targets use the ordinary reference check. */
+function parentFindings(note, index, analysis, unresolved) {
+    const data = dataOf(note);
+    if (data.parents === undefined || data.parents === null) return [];
+    if (!culture(note))
+        return [finding(note, index, [], "data.parents is stated by only culture lore notes")];
+    const findings = [];
+    parentsOf(note).forEach((value, position) => {
+        const tuple = address(value, index);
+        if (!tuple) return;
+        const key = renderAddress(tuple);
+        const target = tuple.type === "lore" ? index.addressHit?.(key) : undefined;
+        if (tuple.type !== "lore") {
+            if (unresolved)
+                findings.push(
+                    finding(
+                        note,
+                        index,
+                        [position],
+                        `data.parents.${position} accepts lore, not ${tuple.type}`,
+                    ),
+                );
+        } else if (!target) {
+            if (unresolved)
+                findings.push(
+                    finding(
+                        note,
+                        index,
+                        [position],
+                        `data.parents.${position} names ${key}, which does not resolve in this package or its declared dependencies`,
+                    ),
+                );
+        } else if (!culture(target))
+            findings.push(
+                finding(
+                    note,
+                    index,
+                    [position],
+                    `data.parents.${position} names ${key}, whose subType is not culture`,
+                ),
+            );
+        else if (analysis.cyclic.get(note)?.has(position))
+            findings.push(
+                finding(
+                    note,
+                    index,
+                    [position],
+                    `data.parents.${position} forms a culture parent cycle; a culture is never its own ancestor`,
+                ),
+            );
+    });
+    return findings;
+}
+
+const graphs = new WeakMap();
+const hierarchyProblems = new WeakMap();
+const inheritedFields = new WeakMap();
+const inheritedSources = new WeakMap();
+
+/** The authored source of one inherited field, retained outside the published record. */
+export function cultureFieldSource(records, key, field) {
+    const record = records.find(
+        (entry) =>
+            entry.type === "lore" &&
+            entry.subType === "culture" &&
+            canonicalKey(entry.package, "note", "lore", entry.shortcode) === key,
+    );
+    return record && inheritedSources.get(record)?.get(field);
+}
+
+/** Fields supplied by an ancestor rather than authored on this record. */
+export function cultureInheritedFields(record) {
+    return inheritedFields.get(record);
+}
+
+/** Read the hierarchy findings retained beside a resolved index record. */
+export function cultureRecordProblems(record) {
+    return hierarchyProblems.get(record);
+}
+
+/** Read hierarchy findings attached to one culture's resolved index record. */
+export function cultureHierarchyProblems(records, key) {
+    return records.flatMap((record) =>
+        (
+            record.type === "lore" &&
+            record.subType === "culture" &&
+            canonicalKey(record.package, "note", "lore", record.shortcode) === key
+        ) ?
+            (hierarchyProblems.get(record) ?? [])
+        :   [],
+    );
+}
+
+/**
+ * Check the declared culture-parent field in the normal frontmatter lint.
+ * @param {object} note - The note's frontmatter and source location.
+ * @param {{index?: object}} [options] - The corpus and its Address lookup.
+ * @returns {object[]} Located findings.
+ */
+export function checkCultureParents(note, { index } = {}) {
+    if (note.reportedCultureParents) return [];
+    const context = index ?? { contentPackage: undefined, notes: [note] };
+    let analysis = graphs.get(context);
+    if (!analysis) {
+        analysis = graph(context);
+        graphs.set(context, analysis);
+    }
+    return parentFindings(note, context, analysis, false);
+}
+
+/**
+ * Resolve each omitted culture field independently, searching parents in listed depth-first order.
+ * Same-depth disagreement withholds the inherited field and produces a finding.
+ * @param {object} index - The authored culture nodes and Address lookup.
+ * @returns {{values: Map<object, object>, findings: object[]}}
+ */
+export function cultureInheritance(index) {
+    const analysis = graph(index);
+    const findings = [];
+    const values = new Map();
+    for (const note of index.notes ?? []) {
+        if (!culture(note)) continue;
+        findings.push(...parentFindings(note, index, analysis, true));
+        const inherited = {};
+        const sources = new Map();
+        for (const field of fields) {
+            if (dataOf(note)[field] !== undefined) continue;
+            const candidates = [];
+            const work = [{ node: note, depth: 0 }];
+            const seen = new Map();
+            while (work.length) {
+                const { node, depth, via } = work.pop();
+                if (analysis.cyclic.get(node)?.size) continue;
+                if (seen.has(node) && seen.get(node) <= depth) continue;
+                seen.set(node, depth);
+                const value = dataOf(node)[field];
+                if (depth && value !== undefined) {
+                    candidates.push({ value, depth, via, node });
+                    continue;
+                }
+                const edges = analysis.out.get(node) ?? [];
+                for (let i = edges.length - 1; i >= 0; i--) {
+                    const edge = edges[i];
+                    if (!analysis.cyclic.get(node)?.has(edge.position))
+                        work.push({
+                            node: edge.target,
+                            depth: depth + 1,
+                            via: depth ? via : edge.position,
+                        });
+                }
+            }
+            const atDepth = new Map();
+            let conflicting;
+            for (const candidate of candidates) {
+                if (
+                    atDepth.has(candidate.depth) &&
+                    !isDeepStrictEqual(atDepth.get(candidate.depth), candidate.value)
+                )
+                    conflicting = candidate;
+                else atDepth.set(candidate.depth, candidate.value);
+            }
+            if (conflicting)
+                findings.push(
+                    finding(
+                        note,
+                        index,
+                        [conflicting.via],
+                        `culture parents at the same depth disagree on data.${field}; state the field on this culture`,
+                    ),
+                );
+            else if (candidates.length) {
+                inherited[field] = candidates[0].value;
+                const source = candidates[0].node;
+                sources.set(field, { file: source.file, raw: source.raw, fm: payload(source) });
+            }
+        }
+        inheritedSources.set(payload(note), sources);
+        values.set(note, inherited);
+    }
+    for (const note of index.notes ?? []) {
+        if (!culture(note)) continue;
+        inheritedFields.set(payload(note), new Set(Object.keys(values.get(note) ?? {})));
+        const relevant = new Set();
+        const work = [note];
+        while (work.length) {
+            const current = work.pop();
+            if (relevant.has(current)) continue;
+            relevant.add(current);
+            work.push(...(analysis.out.get(current) ?? []).map((edge) => edge.target));
+        }
+        const addresses = new Set(
+            [...relevant].map((entry) =>
+                canonicalKey(index.contentPackage, "note", "lore", payload(entry).shortcode),
+            ),
+        );
+        hierarchyProblems.set(
+            payload(note),
+            findings.filter((problem) => addresses.has(problem.cultureAddress)),
+        );
+    }
+    return { values, findings };
+}
+
+/** Emit or collect all findings from culture inheritance. */
+export function reportCultureParents(findings, problems) {
+    if (problems) problems.push(...findings);
+    else if (findings.length)
+        throw Object.assign(new Error(findings.map(formatDiagnostic).join("\n")), {
+            located: true,
+        });
+}

package/engine/frontmatter-lint.mjs

@@ -412,6 +412,7 @@ function checkDataContainer(note, { type, fields, packs, addressContext, index }
     }
 
     for (const field of fields) {
+        if (note.inheritedCultureFields?.has(field.name)) continue;
         if (!field.kind) continue;
         const segments = field.name.split(".");
         let value = entries;
@@ -457,7 +458,12 @@ function checkDataContainer(note, { type, fields, packs, addressContext, index }
 
     // One level down and every level below: each field's value is closed to
     // the inner keys its declaration states, as the container is to its own.
-    findings.push(...checkDataKeys(note, fields));
+    findings.push(
+        ...checkDataKeys(
+            note,
+            fields.filter((field) => !note.inheritedCultureFields?.has(field.name)),
+        ),
+    );
 
     return findings;
 }
@@ -600,6 +606,13 @@ function checkDataReferences(note, field, value, segments, context, index) {
                     :   `; write \`${slot.declines}\` to decline the image on purpose`);
         }
         if (!reason) continue;
+        if (
+            note.fm?.type === "lore" &&
+            note.fm?.subType === "culture" &&
+            field.name === "parents" &&
+            note.reportedCultureParents?.has(check.path[0])
+        )
+            continue;
         const path = ["data", ...segments, ...check.path];
         findings.push({
             file: note.file,
@@ -1526,6 +1539,7 @@ export function lintNote(
         // way a wikilink would. The linter names no such field itself; the
         // vocabulary does, beside the field.
         for (const field of fields) {
+            if (note.inheritedCultureFields?.has(field.name)) continue;
             if (typeof field.check !== "function") continue;
             findings.push(...field.check(note, { index }));
         }

package/engine/metadata-index.mjs

@@ -484,6 +484,17 @@ export function loadForeignIndexes(config, localPackages, bases = PACKAGE_BASE)
                 // place or affiliation inherits from a parent here without
                 // walking that parent's own chain.
                 culture: record.data?.culture ?? undefined,
+                ...(parts.type === "lore" && record.subType === "culture" ?
+                    {
+                        data: {
+                            language: record.data?.language,
+                            appearanceProfile: record.data?.appearanceProfile,
+                        },
+                    }
+                :   {}),
+                ...(parts.type === "skill" && record.subType === "language" ?
+                    { data: { names: record.data?.names } }
+                :   {}),
                 population: record.data?.population ?? undefined,
                 ...(Object.hasOwn(record.data ?? {}, "government") ?
                     { government: record.data.government }

package/engine/note-vocabulary.mjs

@@ -111,6 +111,7 @@ 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 { checkCultureParents } from "./culture-parents.mjs";
 import {
     checkAppearanceProfile,
     profileLookKeys,
@@ -2001,6 +2002,15 @@ export const NOTE_VOCABULARY = Object.freeze({
         ],
         data: Object.freeze([
             ...CALENDAR_FIELDS,
+            {
+                name: "parents",
+                ...LINKS,
+                ref: "lore",
+                accepts: ["lore"],
+                check: checkCultureParents,
+                describe:
+                    "Culture only: parent culture lore notes, searched in listed depth-first order for omitted language and appearance profile fields.",
+            },
             {
                 ...CULTURE_FIELD,
                 describe:

package/package.json

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

package/types/engine/culture-parents.d.mts

@@ -0,0 +1,29 @@
+/** The authored source of one inherited field, retained outside the published record. */
+export function cultureFieldSource(records: any, key: any, field: any): any;
+/** Fields supplied by an ancestor rather than authored on this record. */
+export function cultureInheritedFields(record: any): any;
+/** Read the hierarchy findings retained beside a resolved index record. */
+export function cultureRecordProblems(record: any): any;
+/** Read hierarchy findings attached to one culture's resolved index record. */
+export function cultureHierarchyProblems(records: any, key: any): any;
+/**
+ * Check the declared culture-parent field in the normal frontmatter lint.
+ * @param {object} note - The note's frontmatter and source location.
+ * @param {{index?: object}} [options] - The corpus and its Address lookup.
+ * @returns {object[]} Located findings.
+ */
+export function checkCultureParents(note: object, { index }?: {
+    index?: object;
+}): object[];
+/**
+ * Resolve each omitted culture field independently, searching parents in listed depth-first order.
+ * Same-depth disagreement withholds the inherited field and produces a finding.
+ * @param {object} index - The authored culture nodes and Address lookup.
+ * @returns {{values: Map<object, object>, findings: object[]}}
+ */
+export function cultureInheritance(index: object): {
+    values: Map<object, object>;
+    findings: object[];
+};
+/** Emit or collect all findings from culture inheritance. */
+export function reportCultureParents(findings: any, problems: any): void;