@optolith/entity-descriptions 0.4.8 → 0.4.11

package/lib/entities/profession.js

@@ -7,12 +7,14 @@ import { omitKeys } from "@elyukai/utils/object";
 import { compareNumber } from "@elyukai/utils/ordering";
 import { Reader } from "@elyukai/utils/reader";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { Case, fromUniformCase } from "tsondb/schema/gen";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { combineNameComponents, getNameComponents, renderActivatableNameComponents, renderCombinedActivatableNameComponents, } from "./partial/activatableNameChunks.js";
 import { renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
+import { attributedCustomName, attributedInstance, attributedName } from "./partial/markdown.js";
 import { printProfessionPrerequisites } from "./partial/prerequisites/index.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
-import { formatR, getChildInstancesForInstanceIdR, getInstanceByIdR, localeCompareR, localeJoinR, localeSortR, nameR, strictNameR, translateMapFnR, translateR, translationR, } from "./partial/reader.js";
+import { attributedCustomNameR, attributedNameR, customNameR, formatR, getChildInstancesForInstanceIdR, getInstanceByIdR, localeCompareR, localeJoinR, localeSortR, strictNameR, translateMapFnR, translateR, translationR, } from "./partial/reader.js";
 import { MISSING_VALUE, UNHANDLED_VALUE } from "./partial/unknown.js";
 const prepareProfessionPackages = (professionId) => Reader.asks(({ getInstanceById, getChildInstancesForInstanceId }) => getChildInstancesForInstanceId("ProfessionPackage", professionId)
     .map((professionPackage) => ({
@@ -79,12 +81,12 @@ const renderSkillSpecializationOption = (option) => Reader.asks(({ format, trans
     switch (option.kind) {
         case "Specific":
             return translate("Skill Specialization {$possibleSkills}", {
-                possibleSkills: localeJoin(option.Specific.options.map(id => translateMap(getInstanceById("Skill", id)?.translations)?.name ?? MISSING_VALUE), "disjunction"),
+                possibleSkills: localeJoin(option.Specific.options.map(id => attributedName(translateMap, getInstanceById, "profession", "Skill", id) ??
+                    MISSING_VALUE), "disjunction"),
             });
         case "Group":
             return translate("Skill Specialization for a {$skillOfGroup}", {
-                skillOfGroup: format(translateMap(getInstanceById("SkillGroup", option.Group)?.translations)?.longName ??
-                    MISSING_VALUE, { hiddenCount: 1 }),
+                skillOfGroup: format(attributedCustomName(translateMap, getInstanceById, "profession", t => t.longName, "SkillGroup", option.Group) ?? MISSING_VALUE, { hiddenCount: 1 }),
             });
         default:
             return assertExhaustive(option);
@@ -101,11 +103,11 @@ const renderCombatTechniquesOption = (option) => isNotEmpty(option.fixed)
         })), firstTextR);
         const completeTextR = fixedTextR.then(fixedText => option.rest_rating_modifier === undefined
             ? Reader.of(fixedText)
-            : translateR("{$previous}, all others {$rating}", {
+            : translateR("{$previous}, the others {$rating}", {
                 previous: fixedText,
                 rating: option.rest_rating_modifier + 6,
             }));
-        const listR = Reader.traverse(option.options, strictNameR)
+        const listR = Reader.traverse(option.options, id => attributedNameR("profession", id).map(name => name ?? MISSING_VALUE))
             .thenW(list => localeSortR(list))
             .map(list => list.join(", "));
         return completeTextR.thenW(completeText => listR.map(list => `${completeText}: ${list}`));
@@ -121,11 +123,37 @@ const getTotalingAPValues = (professionPackages, selector) => {
             options[0].ap_value
         : options.map(option => option?.ap_value ?? 0).join("/");
 };
-const renderSkillsOption = (professionPackages, skillGroup) => mapNullable(getTotalingAPValues(professionPackages, pkg => pkg.content.options?.skills?.group === skillGroup.id ? pkg.content.options.skills : undefined), apValue => translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
-    apValue,
-    skillsOfGroup: skillGroup.nameOfSkillsOfGroup,
-})) ?? Reader.of(undefined);
-const renderCantripList = (cantripIds) => Reader.traverse(cantripIds, id => strictNameR("Cantrip", id))
+const renderSkillsOption = (professionPackages, skillGroup) => allSame(professionPackages.filter(pkg => pkg.content.options?.skills?.group === skillGroup.id), on(pkg => pkg.content.options?.skills?.specific, deepEqual))
+    ? (mapNullable(getTotalingAPValues(professionPackages, pkg => pkg.content.options?.skills?.group === skillGroup.id
+        ? pkg.content.options.skills
+        : undefined), apValue => professionPackages[0].content.options?.skills?.specific === undefined
+        ? translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
+            apValue,
+            skillsOfGroup: skillGroup.nameOfSkillsOfGroup,
+        })
+        : Reader.traverse(professionPackages[0].content.options.skills.specific, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE))
+            .thenW(localeSortR)
+            .thenW(list => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
+            apValue,
+            list: list.join(", "),
+        }))) ?? Reader.of(undefined))
+    : Reader.traverse(professionPackages, pkg => {
+        const skillsOption = pkg.content.options?.skills;
+        return skillsOption === undefined
+            ? Reader.of("—")
+            : skillsOption.specific === undefined
+                ? translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
+                    apValue: skillsOption.ap_value,
+                    skillsOfGroup: skillGroup.nameOfSkillsOfGroup,
+                })
+                : Reader.traverse(skillsOption.specific, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE))
+                    .thenW(localeSortR)
+                    .thenW(list => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
+                    apValue: skillsOption.ap_value,
+                    list: list.join(", "),
+                }));
+    }).map(list => list.join(" / "));
+const renderCantripList = (cantripIds) => Reader.traverse(cantripIds, id => attributedNameR("profession", "Cantrip", id).map(name => name ?? MISSING_VALUE))
     .thenW(localeSortR)
     .map(list => list.join(", "));
 const renderVariantCantripsOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
@@ -184,16 +212,15 @@ const renderVariantSkillSpecializationOption = (baseOptions, variantOptions) =>
     remove: (base) => {
         switch (base.kind) {
             case "Specific":
-                return Reader.traverse(base.Specific.options, id => strictNameR("Skill", id))
+                return Reader.traverse(base.Specific.options, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE))
                     .thenW(localeSortR)
                     .thenW(list => localeJoinR(list, "disjunction"))
                     .thenW(skillsText => translateR("no Skill Specialization {$possibleSkills}", {
                     possibleSkills: skillsText,
                 }));
             case "Group":
-                return getInstanceByIdR("SkillGroup", base.Group)
-                    .thenW(translationR)
-                    .map(t => t?.longName ?? MISSING_VALUE)
+                return attributedCustomNameR("profession", t => t.longName, "SkillGroup", base.Group)
+                    .map(name => name ?? MISSING_VALUE)
                     .thenW(longName => formatR(longName, { hiddenCount: 1 }))
                     .thenW(skillOfGroup => translateR("no Skill Specialization for a {$skillOfGroup}", {
                     skillOfGroup,
@@ -205,8 +232,8 @@ const renderVariantSkillSpecializationOption = (baseOptions, variantOptions) =>
     add: override => renderSkillSpecializationOption(override),
     update: (base, override) => {
         if (base.kind === "Specific" && override.kind === "Specific") {
-            const overrideSkills = Reader.traverse(override.Specific.options, id => strictNameR("Skill", id)).thenW(list => localeJoinR(list, "disjunction"));
-            const baseSkills = Reader.traverse(base.Specific.options, id => strictNameR("Skill", id)).thenW(list => localeJoinR(list, "disjunction"));
+            const overrideSkills = Reader.traverse(override.Specific.options, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE)).thenW(list => localeJoinR(list, "disjunction"));
+            const baseSkills = Reader.traverse(base.Specific.options, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE)).thenW(list => localeJoinR(list, "disjunction"));
             return overrideSkills
                 .thenW(overrideSkillsText => baseSkills.thenW(baseSkillsText => insteadOfR(overrideSkillsText, baseSkillsText)))
                 .then(skillsText => translateR("Skill Specialization {$possibleSkills}", {
@@ -234,9 +261,7 @@ const renderVariantCursesOption = (baseOptions, variantOptions) => renderVariant
     })),
 });
 const renderCursesOption = (option) => renderVariantCursesOption(undefined, { kind: "Override", Override: option });
-const nameOfSkillsOfGroupR = (skillGroupId) => getInstanceByIdR("SkillGroup", skillGroupId)
-    .thenW(translationR)
-    .map(t => t?.longName ?? MISSING_VALUE);
+const nameOfSkillsOfGroupR = (skillGroupId) => customNameR(t => t.longName, "SkillGroup", skillGroupId).map(name => name ?? MISSING_VALUE);
 const renderVariantSkillsOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
     remove: base => nameOfSkillsOfGroupR(base.group).thenW(nameOfSkillsOfGroup => translateR("no AP to improve other {$skillsOfGroup}", {
         skillsOfGroup: nameOfSkillsOfGroup,
@@ -257,33 +282,103 @@ const renderVariantLiturgiesOption = (baseOptions, variantOptions) => renderVari
         apValue,
     })),
 });
-const getSpecialAbilityNameComponents = (getInstanceById, getResolvedSelectOptionById, translate, option) => {
+const getEnhancementBaseName = (translate, enhancement, parentName) => {
+    switch (enhancement.parent.kind) {
+        case "Spell":
+            return translate("Spell Enhancement {$spell}", { spell: parentName });
+        case "Ritual":
+            return translate("Ritual Enhancement {$ritual}", { ritual: parentName });
+        case "LiturgicalChant":
+        case "Ceremony":
+            return translate("Liturgical Enhancement {$liturgicalChantOrCeremony}", {
+                liturgicalChantOrCeremony: parentName,
+            });
+        default:
+            return assertExhaustive(enhancement.parent);
+    }
+};
+const isEnhancementNameComponents = (components) => components.id.kind === "Enhancement";
+const isActivatableNameComponents = (components) => !isEnhancementNameComponents(components);
+const getEnhancementNameComponents = (getInstanceById, translate, translateMap, id) => {
+    const instance = getInstanceById("Enhancement", id);
+    if (instance === undefined) {
+        return undefined;
+    }
+    return {
+        id: Case("Enhancement", id),
+        parent: instance.parent,
+        base: getEnhancementBaseName(translate, instance, attributedName(translateMap, getInstanceById, "profession", instance.parent) ?? MISSING_VALUE),
+        options: translateMap(instance.translations)?.name ?? MISSING_VALUE,
+    };
+};
+const renderEnhancementNameComponents = (chunk) => [chunk.base, chunk.options].join(" ");
+const isCombinedEnhancementNameComponents = (components) => Array.isArray(components.id);
+const combineEnhancementNameComponents = (chunks) => {
+    if (allSame(chunks, (a, b) => deepEqual(a.parent, b.parent)) && isNotEmpty(chunks)) {
+        const [first, ...rest] = chunks;
+        return {
+            id: [first.id, ...rest.map(chunk => chunk.id)],
+            parent: first.parent,
+            base: first.base,
+            options: [
+                [first.id, first.options],
+                ...rest.map((chunk) => [
+                    chunk.id,
+                    chunk.options,
+                ]),
+            ],
+        };
+    }
+    else {
+        return undefined;
+    }
+};
+const renderCombinedEnhancementNameComponents = (chunk) => [
+    chunk.base,
+    chunk.options
+        .map(([optionId, optionName]) => attributedInstance(optionName, optionId.kind, optionId.Enhancement, {
+        context: `"profession"`,
+    }))
+        .join(" + "),
+].join(" ");
+const getSpecialAbilityNameComponents = (getInstanceById, getResolvedSelectOptionById, translate, translateMap, option) => {
+    if (option.id.kind === "Enhancement") {
+        return getEnhancementNameComponents(getInstanceById, translate, translateMap, option.id.Enhancement);
+    }
     const instance = getInstanceById(option.id);
     if (instance === undefined) {
         return undefined;
     }
     return getNameComponents(translate, option.id, option.options, option.level, "nameBuilderRules" in instance ? instance.nameBuilderRules : undefined, instance.translations, t => t.name, getResolvedSelectOptionById, true);
 };
+const wrapActivatableInAttributedString = (text, id) => attributedInstance(text, id.kind, fromUniformCase(id), { context: '"prerequisite"' });
+const renderSingleActivatableNameChunk = (translateMap, chunk) => chunk === undefined
+    ? MISSING_VALUE
+    : wrapActivatableInAttributedString(isEnhancementNameComponents(chunk)
+        ? renderEnhancementNameComponents(chunk)
+        : renderActivatableNameComponents(translateMap, chunk, false), chunk.id);
 const renderSpecialAbilityName = (specialAbility) => Reader.asks(({ translate, translateMap, localeJoin, getInstanceById, getResolvedSelectOptionById, }) => {
     switch (specialAbility.kind) {
         case "Constant": {
-            const chunk = getSpecialAbilityNameComponents(getInstanceById, getResolvedSelectOptionById, translate, specialAbility.Constant);
-            return chunk === undefined
-                ? MISSING_VALUE
-                : renderActivatableNameComponents(translateMap, chunk, false);
+            const chunk = getSpecialAbilityNameComponents(getInstanceById, getResolvedSelectOptionById, translate, translateMap, specialAbility.Constant);
+            return renderSingleActivatableNameChunk(translateMap, chunk);
         }
         case "Selection": {
-            const chunks = specialAbility.Selection.options.map(option => getSpecialAbilityNameComponents(getInstanceById, getResolvedSelectOptionById, translate, option));
+            const chunks = specialAbility.Selection.options.map(option => getSpecialAbilityNameComponents(getInstanceById, getResolvedSelectOptionById, translate, translateMap, option));
             const possiblyCombined = isNotEmpty(specialAbility.Selection.options) && chunks.every(isNotNullish)
-                ? combineNameComponents(chunks)
+                ? chunks.every(isEnhancementNameComponents)
+                    ? combineEnhancementNameComponents(chunks)
+                    : chunks.every(isActivatableNameComponents)
+                        ? combineNameComponents(chunks)
+                        : undefined
                 : undefined;
             if (possiblyCombined === undefined) {
-                return localeJoin(chunks.map(chunk => chunk === undefined
-                    ? MISSING_VALUE
-                    : renderActivatableNameComponents(translateMap, chunk, false)), "disjunction");
+                return localeJoin(chunks.map(chunk => renderSingleActivatableNameChunk(translateMap, chunk)), "disjunction");
             }
             else {
-                return renderCombinedActivatableNameComponents(translateMap, possiblyCombined, false, list => localeJoin(list, "disjunction"));
+                return isCombinedEnhancementNameComponents(possiblyCombined)
+                    ? renderCombinedEnhancementNameComponents(possiblyCombined)
+                    : wrapActivatableInAttributedString(renderCombinedActivatableNameComponents(translateMap, possiblyCombined, false, list => localeJoin(list, "disjunction")), possiblyCombined.id);
             }
         }
         default:
@@ -310,7 +405,7 @@ const renderSpecialAbilities = (specialAbilities) => Reader.sequence([
     return result === undefined ? translateR("none") : Reader.of(result);
 });
 const renderCombatTechniques = (professionPackages) => Reader.sequence([
-    renderNumericListAcrossPackages(professionPackages, pkg => Reader.of(pkg.content.combat_techniques?.map(ct => [ct.id, ct.rating_modifier]) ?? []), deepEqual, (ctId) => strictNameR(ctId), 6),
+    renderNumericListAcrossPackages(professionPackages, pkg => Reader.of(pkg.content.combat_techniques?.map(ct => [ct.id, ct.rating_modifier]) ?? []), deepEqual, (ctId) => attributedNameR("profession", ctId).map(name => name ?? MISSING_VALUE), 6),
     professionPackages.some(pkg => pkg.content.options?.combat_techniques !== undefined)
         ? renderSinglePackageValue(professionPackages, pkg => Reader.of(pkg.content.options?.combat_techniques), deepEqual, options => Reader.traverse(options, option => option === undefined ? Reader.of("—") : renderCombatTechniquesOption(option)).map(renderedOptions => renderedOptions.join(" / ")))
         : Reader.of(undefined),
@@ -318,7 +413,7 @@ const renderCombatTechniques = (professionPackages) => Reader.sequence([
 const renderSkills = (professionPackages) => Reader.asks(({ getAllInstances }) => getAllInstances("SkillGroup")).thenW(skillGroups => Reader.traverse(skillGroups.toSorted(on(group => group.content.position, compareNumber)), ({ id: groupId, content: group }) => translationR(group).thenW(groupTranslation => Reader.sequence([
     renderNumericListAcrossPackages(professionPackages, pkg => Reader.asks(({ getInstanceById }) => pkg.content.skills
         ?.filter(skill => getInstanceById("Skill", skill.id)?.group === groupId)
-        .map(skill => [skill.id, skill.rating_modifier]) ?? []), equal, skillId => strictNameR("Skill", skillId), 0),
+        .map(skill => [skill.id, skill.rating_modifier]) ?? []), equal, skillId => attributedNameR("profession", "Skill", skillId).map(name => name ?? MISSING_VALUE), 0),
     renderSkillsOption(professionPackages, {
         id: groupId,
         nameOfSkillsOfGroup: groupTranslation?.longName ?? MISSING_VALUE,
@@ -330,11 +425,11 @@ const renderSkills = (professionPackages) => Reader.asks(({ getAllInstances }) =
 const renderSpellworkName = (spellworkIds) => Reader.traverse(spellworkIds, spellworkId => {
     switch (spellworkId.kind) {
         case "Spellwork":
-            return strictNameR(spellworkId.Spellwork.id).thenW(baseName => (spellworkId.Spellwork.tradition === undefined
+            return attributedNameR("profession", spellworkId.Spellwork.id).thenW(baseName => (spellworkId.Spellwork.tradition === undefined
                 ? Reader.of(undefined)
-                : nameR("MagicalTradition", spellworkId.Spellwork.tradition)).map(traditionName => baseName + parensIf(traditionName)));
+                : attributedNameR("profession", "MagicalTradition", spellworkId.Spellwork.tradition)).map(traditionName => (baseName ?? MISSING_VALUE) + parensIf(traditionName)));
         case "MagicalAction":
-            return strictNameR(spellworkId.MagicalAction.id);
+            return attributedNameR("profession", spellworkId.MagicalAction.id).map(name => name ?? MISSING_VALUE);
         default:
             return spellworkId;
     }
@@ -358,7 +453,7 @@ const retrieveBlessedTraditionIdentifierFromPrerequisites = (prerequisites) => p
             return assertExhaustive(part);
     }
 }) ?? [];
-const renderBlessingList = (blessings) => Reader.traverse(blessings, id => strictNameR("Blessing", id)).thenW(localeSortR);
+const renderBlessingList = (blessings) => Reader.traverse(blessings, id => attributedNameR("profession", "Blessing", id).map(name => name ?? MISSING_VALUE)).thenW(localeSortR);
 const renderRestrictedBlessings = (restrictedBlessings) => {
     switch (restrictedBlessings.kind) {
         case "Three":
@@ -406,7 +501,7 @@ const renderBlessingsForPackages = (professionPackages) => renderBlessings(profe
 const renderBlessingsForVariant = (professionVariant) => renderBlessings([
     retrieveBlessedTraditionIdentifierFromPrerequisites(professionVariant.prerequisites),
 ]).map(blessingsText => (blessingsText !== undefined ? [blessingsText] : []));
-const renderLiturgicalChantName = (liturgyIds) => Reader.traverse(liturgyIds, strictNameR).thenW(list => localeJoinR(list, "disjunction"));
+const renderLiturgicalChantName = (liturgyIds) => Reader.traverse(liturgyIds, id => attributedNameR("profession", id).map(name => name ?? MISSING_VALUE)).thenW(list => localeJoinR(list, "disjunction"));
 const renderLiturgicalChants = (professionPackages) => Reader.sequence([
     renderBlessingsForPackages(professionPackages),
     renderNumericListAcrossPackages(professionPackages, (pkg) => Reader.of(pkg.content.liturgical_chants?.map(ct => [ct.id, ct.rating_modifier]) ?? []), deepEqual, renderLiturgicalChantName, 0),

package/lib/entities/race.d.ts

@@ -3,7 +3,7 @@ import type { CountInstances, GetAllChildInstancesForParent, GetInstanceById } f
  * Get a JSON representation of the rules text for a race.
  */
 export declare const getRaceEntityDescription: import("../creator.js").EntityDescriptionCreator<"Race", {
-    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Advantage" | "Disadvantage" | "Culture">;
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Advantage" | "Disadvantage" | "Culture" | "DerivedCharacteristic">;
     countInstances: CountInstances<"Attribute">;
     getChildInstancesForInstanceId: GetAllChildInstancesForParent<"RaceVariant">;
 }, import("../index.js").EntityDescription>;

package/lib/entities/race.js

@@ -3,24 +3,30 @@ import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { deepEqual } from "@elyukai/utils/equality";
 import { on } from "@elyukai/utils/function";
 import { isNotNullish } from "@elyukai/utils/nullable";
+import { compareNumber } from "@elyukai/utils/ordering";
 import { Reader } from "@elyukai/utils/reader";
 import { sign } from "@elyukai/utils/string/number";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderCommonnessRatedAdvantagesAndDisadvantages, renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
+import { attributedCustomName, attributedName } from "./partial/markdown.js";
+import { getInstanceByIdR, translateMapR, } from "./partial/reader.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
-const renderBaseValueItem = (label, value) => Reader.asks(({ translate }) => ({
-    label: translate(label),
-    value: value < 0 ? sign(value) : value.toFixed(),
-}));
-const renderAttributeAdjustmentsItem = (totalAttributesCount, adjustments) => Reader.asks(({ translate, translateMap, localeJoin, getInstanceById, }) => {
-    const getAttributeAbbreviation = (id) => translateMap(getInstanceById("Attribute", id)?.translations)?.abbreviation ?? MISSING_VALUE;
-    return {
-        label: translate("Attribute Adjustments"),
-        value: [
-            ...(adjustments.fixed?.map(adj => `${getAttributeAbbreviation(adj.id)} ${sign(adj.value)}`) ?? []),
-            ...(adjustments.selectable?.map(adj => `${adj.list.length === totalAttributesCount ? translate("one attribute of your choice") : localeJoin(adj.list.map(getAttributeAbbreviation), "disjunction")} ${sign(adj.value)}`) ?? []),
-        ].join("; "),
-    };
+const renderBaseValues = (values) => Reader.traverse(Object.entries(values), ([id, { value }]) => getInstanceByIdR("DerivedCharacteristic", id).thenW(derivedCharacteristic => translateMapR(derivedCharacteristic?.translations).thenW(translation => Reader.asks(({ translate }) => [
+    derivedCharacteristic?.position ?? 0,
+    {
+        label: translate("{$derivedCharacteristic} Base Value", {
+            derivedCharacteristic: translation?.name ?? MISSING_VALUE,
+        }),
+        value: value < 0 ? sign(value) : value.toFixed(),
+    },
+])))).map(items => items.sort(on(item => item[0], compareNumber)).map(item => item[1]));
+const renderAttributeAdjustmentsItem = (totalAttributesCount, adjustments) => Reader.asks(({ translate, translateMap, localeJoin, getInstanceById }) => {
+    const getAttributeAbbreviation = (id) => attributedCustomName(translateMap, getInstanceById, "race", t => t.abbreviation, "Attribute", id) ?? MISSING_VALUE;
+    return [
+        ...(adjustments.fixed?.map(adj => `${getAttributeAbbreviation(adj.id)} ${sign(adj.value)}`) ??
+            []),
+        ...(adjustments.selectable?.map(adj => `${adj.list.length === totalAttributesCount ? translate("one attribute of your choice") : localeJoin(adj.list.map(getAttributeAbbreviation), "disjunction")} ${sign(adj.value)}`) ?? []),
+    ].join("; ");
 });
 const renderVariantValues = (label, variants, selector, renderValue, translationSelector) => Reader.asks(({ translate, translateMap, localeCompare, localeJoin, }) => {
     const values = variants.map(variant => {
@@ -69,16 +75,13 @@ const renderVariantValues = (label, variants, selector, renderValue, translation
 const renderAutomaticAdvantagesOrDisadvantages = (entity, items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
     ? translate("none")
     : items
-        .map(item => {
-        const instanceTranslation = translateMap(getInstanceById(entity, item.id)?.translations);
-        return (instanceTranslation?.name_in_library ?? instanceTranslation?.name ?? MISSING_VALUE);
-    })
+        .map(item => attributedCustomName(translateMap, getInstanceById, "race", t => t.name_in_library ?? t.name, entity, item.id) ?? MISSING_VALUE)
         .toSorted(localeCompare)
         .join(", "));
 const renderCommonCultures = (items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
     ? translate("none")
     : items
-        .map(itemId => translateMap(getInstanceById("Culture", itemId)?.translations)?.name)
+        .map(itemId => attributedName(translateMap, getInstanceById, "race", "Culture", itemId))
         .filter(isNotNullish)
         .toSorted(localeCompare)
         .join(", "));
@@ -112,11 +115,8 @@ export const getRaceEntityDescription = createEntityDescriptionCreator(({ getIns
                             value: entry.ap_value,
                         }),
                     },
-                    renderBaseValueItem("Life Point Base Value", entry.base_values.life_points).run(env),
-                    renderBaseValueItem("Spirit Base Value", entry.base_values.spirit).run(env),
-                    renderBaseValueItem("Toughness Base Value", entry.base_values.toughness).run(env),
-                    renderBaseValueItem("Movement Base Value", entry.base_values.movement).run(env),
-                    renderAttributeAdjustmentsItem(totalAttributesCount, entry.attribute_adjustments).run(env),
+                    ...renderBaseValues(entry.base_values).run(env),
+                    renderVariantValues("Attribute Adjustments", raceVariants, v => v.attribute_adjustments, attrs => renderAttributeAdjustmentsItem(totalAttributesCount, attrs).run(env)).run(env),
                     renderVariantValues("Common Cultures", raceVariants, v => v.common_cultures, cultures => renderCommonCultures(cultures).run(env)).run(env),
                     entry.automatic_advantages === undefined
                         ? undefined

package/lib/entities/spell.d.ts

@@ -1,6 +1,7 @@
-import { type RatedIdentifier } from "optolith-database-schema/gen";
+import { type ActivatableIdentifier, type RatedIdentifier } from "optolith-database-schema/gen";
 import type { GetAllChildInstancesForParent, GetInstanceById } from "../helpers/getTypes.js";
 import { type IdMap } from "../index.js";
+import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";
 /**
  * Get a JSON representation of the rules text for a cantrip.
  */
@@ -72,7 +73,8 @@ export declare const getAnimistPowerEntityDescription: import("../creator.js").E
  * Get a JSON representation of the rules text for a Goede ritual.
  */
 export declare const getGeodeRitualEntityDescription: import("../creator.js").EntityDescriptionCreator<"GeodeRitual", {
-    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic" | "Influence">;
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic" | "Influence" | ActivatableIdentifier["kind"] | "Aspect">;
+    getResolvedSelectOptionById: GetResolvedSelectOptionById;
 }, import("../index.js").EntityDescription>;
 /**
  * Get a JSON representation of the rules text for a jester trick.

package/lib/entities/spell.js

@@ -11,6 +11,7 @@ import { Case } from "tsondb/schema/gen";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderAnimalTypesSection } from "./partial/animalTypes.js";
 import { renderEnhancements } from "./partial/enhancements.js";
+import { attributedCustomName, attributedName } from "./partial/markdown.js";
 import { printAnimistPowerPrerequisites, printGeodeRitualPrerequisites, } from "./partial/prerequisites/index.js";
 import { renderCastingTime, renderFastSkillNonModifiableCastingTime, renderSlowSkillNonModifiableCastingTime, } from "./partial/rated/activatable/castingTime.js";
 import { renderMagicalActionCost, renderModifiableOneTimeCost, renderNonModifiableOneTimeCost, } from "./partial/rated/activatable/cost.js";
@@ -28,29 +29,18 @@ import { formatEnergyR, localeJoinR, responsiveR, responsiveTextR, responsiveTra
 import { appendNoteIfNeeded, getResponsiveText, ResponsiveTextSize, } from "./partial/responsiveText.js";
 import { formatTimeSpanR } from "./partial/units/timeSpan.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
-const renderProperty = (id) => Reader.asks(({ translate, translateMap, getInstanceById }) => {
-    const text = (() => {
-        const staticEntry = getInstanceById("Property", id);
-        const staticEntryTranslation = translateMap(staticEntry?.translations);
-        if (staticEntryTranslation === undefined) {
-            return "";
-        }
-        return staticEntryTranslation.name;
-    })();
-    return {
-        label: translate("Property"),
-        value: text,
-    };
-});
+const renderProperty = (id) => Reader.asks(({ translate, translateMap, getInstanceById }) => ({
+    label: translate("Property"),
+    value: attributedName(translateMap, getInstanceById, "property", "Property", id) ?? "",
+}));
 const getTextForTraditions = (deps, value) => {
     const text = (() => {
         switch (value.kind) {
             case "General":
                 return deps.translate("General");
             case "Specific":
-                return value.Specific.map(trad => deps.translateMap(deps.getInstanceById("MagicalTradition", trad)?.translations))
+                return value.Specific.map(trad => attributedCustomName(deps.translateMap, deps.getInstanceById, "traditions", t => t.name_for_arcane_spellworks ?? t.name, "MagicalTradition", trad))
                     .filter(isNotNullish)
-                    .map(trad => trad.name_for_arcane_spellworks ?? trad.name)
                     .sort(deps.localeCompare)
                     .join(", ");
             default:
@@ -62,10 +52,7 @@ const getTextForTraditions = (deps, value) => {
         value: text,
     };
 };
-const getTraditionNameForArcaneSpellworksById = (id, getInstanceById, translateMap) => {
-    const translation = translateMap(getInstanceById("MagicalTradition", id)?.translations);
-    return translation?.name_for_arcane_spellworks ?? translation?.name;
-};
+const getTraditionNameForArcaneSpellworksById = (id, getInstanceById, translateMap) => attributedCustomName(translateMap, getInstanceById, "cantrip-note", t => t.name_for_arcane_spellworks ?? t.name, "MagicalTradition", id);
 /**
  * Get a JSON representation of the rules text for a cantrip.
  */
@@ -107,7 +94,7 @@ export const getCantripEntityDescription = createEntityDescriptionCreator(({ get
                                         .map(academyOrTradition => {
                                         switch (academyOrTradition.kind) {
                                             case "Academy":
-                                                return translateMap(getInstanceById("Curriculum", academyOrTradition.Academy)?.translations)?.name;
+                                                return attributedName(translateMap, getInstanceById, "cantrip-note", "Curriculum", academyOrTradition.Academy);
                                             case "Tradition": {
                                                 return mapNullable(getTraditionNameForArcaneSpellworksById(academyOrTradition.Tradition.id, getInstanceById, translateMap), name => name +
                                                     parensIf(translateMap(academyOrTradition.Tradition.translations)?.note));
@@ -296,7 +283,8 @@ export const getCurseEntityDescription = createEntityDescriptionCreator(({ getIn
 const renderMagicalActionSkill = (skill) => Reader.asks(({ translate, translateMap, localeCompare, localeJoin, getInstanceById }) => ({
     label: translate("Skill"),
     value: localeJoin(skill
-        .map(id => translateMap(getInstanceById("Skill", id)?.translations)?.name ?? MISSING_VALUE)
+        .map(id => attributedName(translateMap, getInstanceById, "magical-action-skill", "Skill", id) ??
+        MISSING_VALUE)
         .toSorted(localeCompare), "disjunction"),
 }));
 /**
@@ -383,7 +371,7 @@ export const getDominationRitualEntityDescription = createEntityDescriptionCreat
 const renderMusicTradition = (translate, translateMap, localeCompare, getInstanceById, entity, musicTraditions) => ({
     label: translate("Music Tradition"),
     value: ensureNonEmpty(musicTraditions
-        .map(trad => translateMap(getInstanceById(entity, trad.id)?.translations)?.name)
+        .map(trad => attributedName(translateMap, getInstanceById, "music-tradition", entity, trad.id))
         .filter(isNotNullish)
         .toSorted(localeCompare))?.join(", ") ?? MISSING_VALUE,
 });
@@ -472,7 +460,7 @@ export const getMagicalMelodyEntityDescription = createEntityDescriptionCreator(
 const renderFamiliarsTrickProperty = (translateMap, getInstanceById, responsiveTextSize, property) => {
     switch (property.kind) {
         case "Fixed":
-            return (translateMap(getInstanceById("Property", property.Fixed)?.translations)?.name ??
+            return (attributedName(translateMap, getInstanceById, "property", "Property", property.Fixed) ??
                 MISSING_VALUE);
         case "Indefinite":
             return getResponsiveText(translateMap(property.Indefinite.translations)?.description, responsiveTextSize);
@@ -573,7 +561,7 @@ const renderAnimistPowerTribeTradition = (translate, translateMap, localeCompare
         return translate("General");
     }
     return (ensureNonEmpty(tribeTradition
-        .map(id => translateMap(getInstanceById("Tribe", id)?.translations)?.name)
+        .map(id => attributedName(translateMap, getInstanceById, "tribe", "Tribe", id))
         .filter(isNotNullish)
         .toSorted(localeCompare))?.join(", ") ?? MISSING_VALUE);
 };
@@ -678,7 +666,7 @@ export const getAnimistPowerEntityDescription = createEntityDescriptionCreator((
 /**
  * Get a JSON representation of the rules text for a Goede ritual.
  */
-export const getGeodeRitualEntityDescription = createEntityDescriptionCreator(({ getInstanceById }, locale, { content: entry }) => {
+export const getGeodeRitualEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getResolvedSelectOptionById }, locale, { content: entry }) => {
     const { translate, translateMap } = locale;
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
@@ -719,7 +707,7 @@ export const getGeodeRitualEntityDescription = createEntityDescriptionCreator(({
                         ? undefined
                         : {
                             label: translate("Prerequisites"),
-                            value: printGeodeRitualPrerequisites(getInstanceById, locale, entry.prerequisites),
+                            value: printGeodeRitualPrerequisites(getInstanceById, getResolvedSelectOptionById, locale, entry.prerequisites),
                         },
                     renderProperty(entry.property).run(env),
                     {
@@ -848,7 +836,7 @@ const renderMagicalRuneCost = (options, cost) => {
     }
 };
 const renderSplitMagicalRuneParameterTranslation = (parameter) => responsiveR(() => parameter.fast.full, () => parameter.fast.abbr).map2(responsiveR(() => parameter.slow.full, () => parameter.slow.abbr), (fast, slow) => `${slow} / ${fast}`);
-const renderMagicalRunCraftingTimePart = (craftingTime, unit) => formatTimeSpanR(unit, craftingTime.value).thenW(text => {
+const renderMagicalRuneCraftingTimePart = (craftingTime, unit) => formatTimeSpanR(unit, craftingTime.value).thenW(text => {
     if (craftingTime.per === undefined) {
         return Reader.of(text);
     }
@@ -863,7 +851,7 @@ const renderMagicalRunCraftingTimePart = (craftingTime, unit) => formatTimeSpanR
         }));
     });
 });
-const renderMagicalRuneCraftingTime = (craftingTime) => renderMagicalRunCraftingTimePart(craftingTime, "Actions").map2(renderMagicalRunCraftingTimePart(craftingTime, "Days"), (fast, slow) => `${slow} / ${fast}`);
+const renderMagicalRuneCraftingTime = (craftingTime) => renderMagicalRuneCraftingTimePart(craftingTime, "Actions").map2(renderMagicalRuneCraftingTimePart(craftingTime, "Days"), (fast, slow) => `${slow} / ${fast}`);
 const renderMagicalRuneDuration = (duration) => renderCheckResultBasedDuration(duration.fast).map2(renderCheckResultBasedDuration(duration.slow), (fast, slow) => `${slow} / ${fast}`);
 const renderMagicalRuneImprovementCost = (options, improvementCost) => {
     switch (improvementCost.kind) {