@heroiclands/package-build 23.5.1 → 23.6.0

package/engine/glossary-entries.mjs

@@ -0,0 +1,182 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * A culture's or an affiliation's own glossary terms: `data.glossary` on a
+ * `lore` note of `subType: culture` or on an `affiliation`, a list of
+ * `{ name, name_sort?, common?, definition?, pronunciation?, language? }`.
+ *
+ * It holds the terms that belong to the people or body using them rather than
+ * to a language's grammar: euphemisms, idioms, terms of art, and titles that
+ * are not ranks. An entry with a `definition` creates a term or replaces every
+ * sense the term's other sources give it. An entry without one changes no
+ * sense, and only marks a term the note already has — a word of a language
+ * that reaches it, or a rank or office — as common, sorted or pronounced.
+ *
+ * The shape is the inner-key check's; this check owns what an entry means:
+ *
+ * - an error on `data.glossary` written on a `lore` note that is not a
+ *   culture, at the key;
+ * - an error on two entries of one name, compared after NFC normalisation and
+ *   case kept, at the second;
+ * - an error on an entry's `language` that names a note other than a language
+ *   skill, or nothing, at the value;
+ * - an error on an entry that resolves to no language
+ *   ({@link module:engine/glossary-language}), at the entry;
+ * - an error on an entry with no definition that names no term of the note, at
+ *   its name;
+ * - an error on a pronunciation that is not a respelling, at the value;
+ * - a warning on a definition that only repeats the one sense it replaces, at
+ *   the definition.
+ *
+ * @module
+ */
+
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+import {
+    addressKeyOf,
+    entryLanguage,
+    glossaryName,
+    isCultureNote,
+    noteTerms,
+} from "./culture-reach.mjs";
+import { pronunciationProblem } from "./word-terms.mjs";
+
+/** Whether a value is a plain map. */
+const isMap = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+
+/**
+ * Check a culture's or an affiliation's `data.glossary`.
+ *
+ * @param {object} note - A `lore` or `affiliation` note.
+ * @param {{index?: object}} [context] - The index, for what the note's terms
+ *   and languages are. Without one, only what the note says of itself is
+ *   checked.
+ * @returns {object[]} The findings.
+ */
+export function checkGlossary(note, { index } = {}) {
+    const data = note?.fm?.data;
+    if (!isMap(data) || data.glossary === undefined || data.glossary === null) return [];
+    const raw = note.raw ?? "";
+    const at = (path, severity, message, key = false) => ({
+        file: note.file,
+        ...positionOfFrontmatterPath(raw, ["data", "glossary", ...path], { key }),
+        severity,
+        message,
+    });
+    const type = String(note?.type ?? note?.fm?.type ?? "").toLowerCase();
+    if (type !== "affiliation" && !isCultureNote(note))
+        return [
+            at(
+                [],
+                "error",
+                "`data.glossary` states a culture's own glossary terms, and this note's " +
+                    "`subType` is not `culture`",
+                true,
+            ),
+        ];
+    if (!Array.isArray(data.glossary)) return [];
+
+    const findings = [];
+    const terms = index?.notes ? noteTerms(index, note) : undefined;
+    const seen = new Set();
+    data.glossary.forEach((entry, i) => {
+        if (!isMap(entry) || typeof entry.name !== "string" || !entry.name.trim()) return;
+        const name = glossaryName(entry.name);
+        if (seen.has(name)) {
+            findings.push(
+                at(
+                    [i, "name"],
+                    "error",
+                    `\`${entry.name}\` stands twice in this glossary; one entry says ` +
+                        "everything the note says of a term",
+                ),
+            );
+            return;
+        }
+        seen.add(name);
+        if (typeof entry.pronunciation === "string") {
+            const problem = pronunciationProblem(entry.pronunciation);
+            if (problem)
+                findings.push(
+                    at(
+                        [i, "pronunciation"],
+                        "error",
+                        `\`data.glossary[${i}].pronunciation\` is not a respelling: ${problem}`,
+                    ),
+                );
+        }
+        if (!terms) return;
+        const stated = entry.language !== undefined && entry.language !== null;
+        const named = stated ? languageProblem(index, entry.language) : undefined;
+        if (named) findings.push(at([i, "language"], "error", named));
+        else if (!entryLanguage(index, note, entry))
+            findings.push(
+                at(
+                    [i],
+                    "error",
+                    `\`${entry.name}\` resolves to no language: the entry states no ` +
+                        "`language`, and " +
+                        (type === "affiliation" ?
+                            "neither the affiliation, its parents nor its culture states one"
+                        :   "the culture states no `data.language`") +
+                        "; state `language` on the entry or `data.language` on the note",
+                ),
+            );
+        const senses = terms.get(name);
+        const defined = typeof entry.definition === "string" && entry.definition.trim() !== "";
+        if (!defined && !senses)
+            findings.push(
+                at(
+                    [i, "name"],
+                    "error",
+                    `\`${entry.name}\` names nothing: it is no word of a language that reaches ` +
+                        "this note and no rank or office it holds, and the entry gives no " +
+                        "`definition` to make it a term",
+                ),
+            );
+        else if (defined && senses?.length === 1 && senses[0].trim() === entry.definition.trim())
+            findings.push(
+                at(
+                    [i, "definition"],
+                    "warning",
+                    `the definition of \`${entry.name}\` repeats the one sense it replaces; ` +
+                        "leave `definition` out",
+                ),
+            );
+    });
+    return findings;
+}
+
+/**
+ * Why an entry's `language` names no language skill, or `undefined` when it
+ * names one.
+ *
+ * @param {object} index - The link index.
+ * @param {unknown} value - The entry's `language`.
+ * @returns {string|undefined}
+ */
+function languageProblem(index, value) {
+    const key = addressKeyOf(value, index, "skill");
+    if (!key) return `\`language\` is not an Address: ${JSON.stringify(value)}`;
+    const target = index.addressHit?.(key);
+    if (!target)
+        return (
+            `\`language\` names ${key}, which does not resolve in this package or its declared ` +
+            "dependencies"
+        );
+    const fm = target.fm ?? target;
+    if (String(fm.type ?? "").toLowerCase() === "skill" && fm.subType === "language")
+        return undefined;
+    return `\`language\` names ${key}, which is not a skill whose subType is language`;
+}

package/engine/glossary-language.mjs

@@ -0,0 +1,99 @@
+/*
+ * 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
+ */
+
+/**
+ * The language a glossary term is in. The first match wins:
+ *
+ * 1. the entry's own `language`;
+ * 2. the note it is written on, when that note is a language;
+ * 3. on an affiliation, its own `data.language`, then the nearest parent
+ *    affiliation's (breadth first, parents in the order listed), then its
+ *    culture's `data.language`;
+ * 4. on a culture, its own `data.language`.
+ *
+ * An affiliation's culture is the one the index resolves for it, its own or
+ * one inherited through its parents, and a culture's language includes one it
+ * inherits from its parent cultures. The lint and the `glossary` relation both
+ * resolve through here, each handing over how it reads an Address and looks a
+ * note up.
+ *
+ * A leaf module, importing nothing.
+ *
+ * @module
+ */
+
+/** A note's parsed frontmatter, whichever shape the caller hands over. */
+const payload = (note) => note?.fm ?? note ?? {};
+
+/** A note's `data`, or an empty map. */
+const dataOf = (note) => {
+    const data = payload(note).data;
+    return data && typeof data === "object" && !Array.isArray(data) ? data : {};
+};
+
+/** A note's type or subType, lowercased. */
+const lower = (value) => String(value ?? "").toLowerCase();
+
+/**
+ * How a caller reads Addresses and finds notes.
+ *
+ * @typedef {object} GlossaryLanguageReader
+ * @property {(value: unknown, type: string) => string|undefined} keyOf - A
+ *   value's canonical Address in the `note` system, read with `type` as the
+ *   default type, or `undefined` where it is no Address.
+ * @property {(key: string) => object|undefined} lookup - The note an Address
+ *   names, or `undefined` where none is known.
+ * @property {string} [self] - The owning note's own Address, for a language.
+ */
+
+/**
+ * The language a glossary entry resolves to.
+ *
+ * @param {object|undefined} entry - The entry, or nothing for the note's own
+ *   language.
+ * @param {object} owner - The note the entry is written on.
+ * @param {GlossaryLanguageReader} reader - How to read Addresses and notes.
+ * @returns {string|undefined} The language's Address, or `undefined` where the
+ *   chain finds none.
+ */
+export function glossaryLanguage(entry, owner, { keyOf, lookup, self }) {
+    const own = keyOf(entry?.language, "skill");
+    if (own) return own;
+    const fm = payload(owner);
+    const type = lower(fm.type);
+    if (type === "skill" && lower(fm.subType) === "language") return self;
+    if (type === "lore" && lower(fm.subType) === "culture")
+        return keyOf(dataOf(owner).language, "skill");
+    if (type !== "affiliation") return undefined;
+
+    const seen = new Set();
+    let level = [owner];
+    while (level.length) {
+        const next = [];
+        for (const body of level) {
+            if (seen.has(body)) continue;
+            seen.add(body);
+            const language = keyOf(dataOf(body).language, "skill");
+            if (language) return language;
+            for (const parent of Array.isArray(dataOf(body).parents) ? dataOf(body).parents : []) {
+                const key = keyOf(parent, "affiliation");
+                const target = key ? lookup(key) : undefined;
+                if (target && lower(payload(target).type) === "affiliation") next.push(target);
+            }
+        }
+        level = next;
+    }
+    const culture = keyOf(dataOf(owner).culture, "lore");
+    const target = culture ? lookup(culture) : undefined;
+    return target ? keyOf(dataOf(target).language, "skill") : undefined;
+}

package/engine/index.mjs

@@ -216,6 +216,7 @@ export * as contentLint from "./content-lint.mjs";
 
 /** The charset authored content is held to, so a book can choose its face. */
 export * as contentCharset from "./content-charset.mjs";
+export * as pathCharset from "./path-charset.mjs";
 
 /** Naming an interface icon in a note, without drawing one there. */
 export * as contentIcons from "./content-icons.mjs";

package/engine/infobox.mjs

@@ -317,6 +317,14 @@ export const NOTE_FIELD_PRESENTATION = Object.freeze({
     "map.scene": Object.freeze({ withheld: "canvas machinery, not a summary row" }),
     "map.fixup": Object.freeze({ withheld: "canvas machinery, not a summary row" }),
     "map.thumbnail": Object.freeze({ withheld: "an image, which the box never carries" }),
+    // A language's words and a glossary's terms are what dictionary sections
+    // are drawn from, not facts a summary row can carry.
+    "skill.classModifiers": Object.freeze({ withheld: "word machinery, not a summary row" }),
+    "skill.fields": Object.freeze({ withheld: "word machinery, not a summary row" }),
+    "skill.words": Object.freeze({ withheld: "word machinery, not a summary row" }),
+    "skill.affixes": Object.freeze({ withheld: "word machinery, not a summary row" }),
+    "lore.glossary": Object.freeze({ withheld: "glossary machinery, not a summary row" }),
+    "affiliation.glossary": Object.freeze({ withheld: "glossary machinery, not a summary row" }),
 
     assocSkill: Object.freeze({ label: "Skill" }),
     assocAffiliation: Object.freeze({ label: "Affiliation" }),

package/engine/language-words.mjs

@@ -0,0 +1,360 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * A language's words: `data.words` on a `skill` note of `subType: language`,
+ * with the `data.classModifiers`, `data.fields` and `data.affixes` they are
+ * read against. The language of a word is the note it sits on.
+ *
+ * The inner-key check holds every entry to its declared keys and kinds. This
+ * check owns what the values mean, each finding located at the key at fault:
+ *
+ * - no skill of another subType states these keys;
+ * - a word's `class` is a master-set base followed by master-set modifiers,
+ *   each declared in `data.classModifiers`, and a declared modifier no word
+ *   uses is a warning;
+ * - a word's `field` is one of `data.fields`;
+ * - a `borrowed` source names its `language`;
+ * - no form stands twice in one language;
+ * - every `attested` Address and source language resolves, and a source
+ *   language names a language skill;
+ * - a pronunciation is a respelling;
+ * - a `built` piece no word or affix of the language glosses is a warning.
+ *
+ * {@link checkLanguageFamily} owns `data.family`, the parent language a
+ * daughter reads words from: it is stated only on a language, names a
+ * language, and its chain never returns to the note it starts from.
+ * {@link checkLanguageAbbreviation} owns `data.abbreviation`, the tag a
+ * dictionary prints for the language: it is stated only on a language, and is
+ * not blank.
+ *
+ * @module
+ */
+
+import { pathLabel as label } from "./data-keys.mjs";
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+import { readCanonicalKey } from "./address.mjs";
+import { addressKeyOf, ownKey } from "./culture-reach.mjs";
+import {
+    BORROWED_SOURCE_KIND,
+    LANGUAGE_SUBTYPE,
+    WORD_DATA_KEYS,
+    pronunciationProblem,
+} from "./word-terms.mjs";
+import { WORD_CLASS_MODIFIERS, parseWordClass } from "./word-classes.mjs";
+import { pieceGlosses } from "./word-rows.mjs";
+
+const MODIFIER_TOKENS = new Set(WORD_CLASS_MODIFIERS.map((item) => item.token));
+
+/** Whether a value is a plain map. */
+const isMap = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+
+/** A list value, or an empty one. */
+const listOf = (value) => (Array.isArray(value) ? value : []);
+
+/**
+ * Check a `skill` note's words against what they mean.
+ *
+ * @param {object} note - A `skill` note.
+ * @param {{index?: object}} [context] - The index, for whether an Address
+ *   resolves. Without one, only what the note says of itself is checked.
+ * @returns {object[]} The findings.
+ */
+export function checkLanguageWords(note, { index } = {}) {
+    const fm = note?.fm ?? {};
+    const data = isMap(fm.data) ? fm.data : {};
+    const raw = note.raw ?? "";
+    const finding = (path, severity, message, key = false) => ({
+        file: note.file,
+        ...positionOfFrontmatterPath(raw, path, { key }),
+        severity,
+        message,
+    });
+    const stated = (key) => data[key] !== undefined && data[key] !== null;
+
+    if (String(fm.subType ?? "").toLowerCase() !== LANGUAGE_SUBTYPE)
+        return WORD_DATA_KEYS.filter(stated).map((key) =>
+            finding(
+                ["data", key],
+                "error",
+                `\`data.${key}\` holds a language's words, and this note's \`subType\` is not ` +
+                    `\`${LANGUAGE_SUBTYPE}\``,
+                true,
+            ),
+        );
+
+    const findings = [];
+
+    const declared = new Map();
+    listOf(data.classModifiers).forEach((token, i) => {
+        if (typeof token === "string" && MODIFIER_TOKENS.has(token) && !declared.has(token))
+            declared.set(token, i);
+    });
+    const fieldNames = new Set(
+        listOf(data.fields)
+            .filter((field) => isMap(field) && typeof field.name === "string")
+            .map((field) => field.name),
+    );
+    /**
+     * Whether an Address resolves, and, for a language, names a language skill.
+     *
+     * @param {unknown} value - The Address as the note holds it.
+     * @param {Array<string|number>} path - Where it sits.
+     * @param {string} type - The type a bare shortcode defaults to.
+     * @returns {object[]} The findings.
+     */
+    function addressFindings(value, path, type) {
+        if (!index?.addressHit || value === undefined || value === null) return [];
+        const key = addressKeyOf(value, index, type);
+        if (!key)
+            return [
+                finding(
+                    path,
+                    "error",
+                    `\`${label(path)}\` is not an Address: ${JSON.stringify(value)}`,
+                ),
+            ];
+        const target = index.addressHit(key);
+        if (!target)
+            return [
+                finding(
+                    path,
+                    "error",
+                    `\`${label(path)}\` names ${key}, which does not resolve in this package or ` +
+                        "its declared dependencies",
+                ),
+            ];
+        return [{ target, key }];
+    }
+
+    /** As {@link addressFindings}, and the target must be a language skill. */
+    function languageFindings(value, path) {
+        const out = [];
+        for (const result of addressFindings(value, path, "skill")) {
+            if (!result.target) {
+                out.push(result);
+                continue;
+            }
+            const target = result.target.fm ?? result.target;
+            if (target.type === "skill" && target.subType === "language") continue;
+            out.push(
+                finding(
+                    path,
+                    "error",
+                    `\`${label(path)}\` names ${result.key}, which is not a skill whose subType ` +
+                        "is language",
+                ),
+            );
+        }
+        return out;
+    }
+
+    const glossOf = pieceGlosses(data);
+    const used = new Set();
+    const forms = new Map();
+    listOf(data.words).forEach((word, i) => {
+        if (!isMap(word)) return;
+        const at = (key) => ["data", "words", i, key];
+
+        if (typeof word.class === "string") {
+            const parsed = parseWordClass(word.class);
+            if (parsed.reason)
+                findings.push(
+                    finding(at("class"), "error", `the class \`${word.class}\`: ${parsed.reason}`),
+                );
+            else
+                for (const token of parsed.modifiers) {
+                    used.add(token);
+                    if (!declared.has(token))
+                        findings.push(
+                            finding(
+                                at("class"),
+                                "error",
+                                `the modifier \`${token}\` in \`${word.class}\` is not declared in ` +
+                                    "`data.classModifiers`",
+                            ),
+                        );
+                }
+        }
+
+        if (typeof word.field === "string" && !fieldNames.has(word.field))
+            findings.push(
+                finding(
+                    at("field"),
+                    "error",
+                    `the field \`${word.field}\` is not one of this language's \`data.fields\``,
+                ),
+            );
+
+        if (typeof word.form === "string") {
+            const key = word.form.normalize("NFC");
+            if (forms.has(key))
+                findings.push(
+                    finding(
+                        at("form"),
+                        "error",
+                        `\`${word.form}\` stands twice in this language, first at ` +
+                            `\`data.words[${forms.get(key)}]\``,
+                    ),
+                );
+            else forms.set(key, i);
+        }
+
+        if (isMap(word.source)) {
+            if (word.source.kind === BORROWED_SOURCE_KIND && (word.source.language ?? "") === "")
+                findings.push(
+                    finding(
+                        at("source"),
+                        "error",
+                        "a `borrowed` source names the tongue the word was borrowed from in its `language`",
+                    ),
+                );
+            findings.push(...languageFindings(word.source.language, [...at("source"), "language"]));
+        }
+
+        listOf(word.attested).forEach((value, j) => {
+            for (const result of addressFindings(value, [...at("attested"), j], undefined))
+                if (!result.target) findings.push(result);
+        });
+
+        if (typeof word.pronunciation === "string") {
+            const problem = pronunciationProblem(word.pronunciation);
+            if (problem)
+                findings.push(
+                    finding(
+                        at("pronunciation"),
+                        "error",
+                        `\`data.words[${i}].pronunciation\` is not a respelling: ${problem}`,
+                    ),
+                );
+        }
+
+        listOf(word.built).forEach((piece, j) => {
+            if (typeof piece !== "string" || glossOf(piece) !== null) return;
+            findings.push(
+                finding(
+                    [...at("built"), j],
+                    "warning",
+                    `the piece \`${piece}\` of \`${word.form}\` matches no word or affix of this ` +
+                        "language, so it prints with no gloss",
+                ),
+            );
+        });
+    });
+
+    for (const [token, i] of declared)
+        if (!used.has(token))
+            findings.push(
+                finding(
+                    ["data", "classModifiers", i],
+                    "warning",
+                    `the modifier \`${token}\` is declared, and no word uses it`,
+                ),
+            );
+
+    return findings;
+}
+
+/**
+ * Check a `skill` note's `data.abbreviation`: an error on a skill of another
+ * subType, at the key, and on a blank value, at the value.
+ *
+ * @param {object} note - A `skill` note.
+ * @returns {object[]} The findings.
+ */
+export function checkLanguageAbbreviation(note) {
+    const fm = note?.fm ?? {};
+    const value = isMap(fm.data) ? fm.data.abbreviation : undefined;
+    if (value === undefined || value === null) return [];
+    const finding = (message, key = false) => ({
+        file: note.file,
+        ...positionOfFrontmatterPath(note.raw ?? "", ["data", "abbreviation"], { key }),
+        severity: "error",
+        message,
+    });
+    if (String(fm.subType ?? "").toLowerCase() !== LANGUAGE_SUBTYPE)
+        return [
+            finding(
+                "`data.abbreviation` is the tag a dictionary prints for a language, and this " +
+                    `note's \`subType\` is not \`${LANGUAGE_SUBTYPE}\``,
+                true,
+            ),
+        ];
+    if (typeof value === "string" && !value.trim())
+        return [
+            finding("`data.abbreviation` is blank; state the tag, as `Prov.`, or leave it out"),
+        ];
+    return [];
+}
+
+/**
+ * Check a `skill` note's `data.family`.
+ *
+ * An Address that does not resolve is the reference check's to report, so this
+ * speaks about a key on the wrong subType, a target that is not a language, and
+ * a chain of parents that returns to this note.
+ *
+ * @param {object} note - A `skill` note.
+ * @param {{index?: object}} [context] - The index, for what the chain reaches.
+ * @returns {object[]} The findings.
+ */
+export function checkLanguageFamily(note, { index } = {}) {
+    const fm = note?.fm ?? {};
+    const value = isMap(fm.data) ? fm.data.family : undefined;
+    if (value === undefined || value === null) return [];
+    const raw = note.raw ?? "";
+    const finding = (message, key = false) => ({
+        file: note.file,
+        ...positionOfFrontmatterPath(raw, ["data", "family"], { key }),
+        severity: "error",
+        message,
+    });
+    if (String(fm.subType ?? "").toLowerCase() !== LANGUAGE_SUBTYPE)
+        return [
+            finding(
+                "`data.family` names the parent of a language, and this note's `subType` is " +
+                    `not \`${LANGUAGE_SUBTYPE}\``,
+                true,
+            ),
+        ];
+    if (!index?.addressHit) return [];
+    const key = addressKeyOf(value, index, "skill");
+    const target = key ? index.addressHit(key) : undefined;
+    if (!target) return [];
+    // The type is the Address's own; the subType is the target's.
+    const isLanguage = (address, hit) =>
+        readCanonicalKey(address)?.type === "skill" &&
+        (hit?.fm ?? hit)?.subType === LANGUAGE_SUBTYPE;
+    if (!isLanguage(key, target))
+        return [
+            finding(`\`data.family\` names ${key}, which is not a skill whose subType is language`),
+        ];
+    const own = ownKey(note, index);
+    const seen = new Set();
+    let current = key;
+    while (current && !seen.has(current)) {
+        if (current === own)
+            return [
+                finding(
+                    `\`data.family\` names ${key}, and the chain of parents returns to this ` +
+                        "language: a family is a cycle",
+                ),
+            ];
+        seen.add(current);
+        const hit = index.addressHit(current);
+        if (!isLanguage(current, hit)) break;
+        const payload = hit.fm ?? hit;
+        current = addressKeyOf(payload.data?.family, index, "skill");
+    }
+    return [];
+}