@optolith/entity-descriptions 0.4.7 → 0.4.10

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.4.10](https://github.com/Optolith/entity-descriptions/compare/v0.4.9...v0.4.10) (2026-03-17)
+
+## [0.4.9](https://github.com/Optolith/entity-descriptions/compare/v0.4.8...v0.4.9) (2026-03-17)
+
+
+### Features
+
+* mark generated instances with attributed strings ([85cce91](https://github.com/Optolith/entity-descriptions/commit/85cce917d16ac10833d4dccf7031c2dca4e75d26))
+
+
+### Bug Fixes
+
+* always append level to activatable name ([10ca82a](https://github.com/Optolith/entity-descriptions/commit/10ca82a1e57afd2d11ba7c32b55a49172e676398))
+* require previous level and fix function typo ([2b12a01](https://github.com/Optolith/entity-descriptions/commit/2b12a01beaaf786843edbbcf42def3d1b1ecb673))
+
+## [0.4.8](https://github.com/Optolith/entity-descriptions/compare/v0.4.7...v0.4.8) (2026-03-15)
+
+
+### Bug Fixes
+
+* render style and advanced special ability values ([d7a2a99](https://github.com/Optolith/entity-descriptions/commit/d7a2a99188976ea626e917da0085726cb02f7e26))
+
 ## [0.4.7](https://github.com/Optolith/entity-descriptions/compare/v0.4.6...v0.4.7) (2026-03-15)
 
 

package/lib/entities/activatable.d.ts

@@ -1,7 +1,10 @@
-import type { ActivatableIdentifier, AdvantageDisadvantagePrerequisites, AdventurePointsValue, ApplicableCombatTechniques, Aspect_ID, CombatSpecialAbilityUsageType, DaggerRitualCost, EnchantmentCost, Errata, GeneralPrerequisites, MagicalSignCost, Penalty, PropertyDeclaration, PublicationRefs, RatedIdentifier, SelectOptions, SpecialRule, Volume } from "optolith-database-schema/gen";
+import type { ActivatableIdentifier, AdvancedSpecialAbility, AdvantageDisadvantagePrerequisites, AdventurePointsValue, ApplicableCombatTechniques, Aspect_ID, CombatSpecialAbilityUsageType, DaggerRitualCost, EnchantmentCost, Errata, GeneralPrerequisites, MagicalSignCost, Penalty, PropertyDeclaration, PublicationRefs, RatedIdentifier, SelectOptions, SpecialRule, Volume } from "optolith-database-schema/gen";
+import { Case } from "tsondb/schema/gen";
 import type { GetAllInstances, GetInstanceById } from "../helpers/getTypes.js";
 import type { GetAllResolvedNewSkillApplications, GetAllResolvedSelectOptions, GetAllResolvedSkillUses } from "../index.js";
-import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";
+import { type GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";
+type AdvancedSpecialAbilityKind = "AdvancedSkillSpecialAbility" | "AdvancedCombatSpecialAbility" | "AdvancedMagicalSpecialAbility" | "AdvancedKarmaSpecialAbility";
+type AdvancedIdentifierSpecialAbility = string | Case<AdvancedSpecialAbilityKind, string>;
 /**
  * The base fields for a special ability entity in the database.
  */
@@ -10,6 +13,7 @@ export type BaseActivatable = {
     maximum?: number;
     select_options?: SelectOptions;
     usage_type?: CombatSpecialAbilityUsageType;
+    advanced?: AdvancedSpecialAbility<AdvancedIdentifierSpecialAbility>[];
     penalty?: Penalty;
     combat_techniques?: ApplicableCombatTechniques;
     volume?: Volume;
@@ -43,10 +47,11 @@ export type BaseActivatableTranslation = {
  * Get a JSON representation of the rules text for a special ability.
  */
 export declare const getActivatableEntityDescription: import("../creator.js").EntityDescriptionCreator<"Advantage" | "Disadvantage" | "AdvancedCombatSpecialAbility" | "AdvancedKarmaSpecialAbility" | "AdvancedMagicalSpecialAbility" | "AdvancedSkillSpecialAbility" | "AncestorGlyph" | "ArcaneOrbEnchantment" | "AttireEnchantment" | "Beutelzauber" | "BlessedTradition" | "BowlEnchantment" | "BrawlingSpecialAbility" | "CauldronEnchantment" | "CeremonialItemSpecialAbility" | "ChronicleEnchantment" | "CombatSpecialAbility" | "CombatStyleSpecialAbility" | "CommandSpecialAbility" | "DaggerRitual" | "FamiliarSpecialAbility" | "FatePointSexSpecialAbility" | "FatePointSpecialAbility" | "FoolsHatEnchantment" | "GeneralSpecialAbility" | "Haubenzauber" | "InstrumentEnchantment" | "KarmaSpecialAbility" | "Krallenkettenzauber" | "Kristallkugelzauber" | "LiturgicalStyleSpecialAbility" | "LycantropicGift" | "MagicalSign" | "MagicalSpecialAbility" | "MagicalTradition" | "MagicStyleSpecialAbility" | "OrbEnchantment" | "PactGift" | "ProtectiveWardingCircleSpecialAbility" | "RingEnchantment" | "Sermon" | "SexSpecialAbility" | "SickleRitual" | "SikaryanDrainSpecialAbility" | "SkillStyleSpecialAbility" | "SpellSwordEnchantment" | "StaffEnchantment" | "ToyEnchantment" | "Trinkhornzauber" | "VampiricGift" | "Vision" | "WandEnchantment" | "WeaponEnchantment", {
-    getInstanceById: GetInstanceById<"Publication" | "Subject" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "TradeSecret" | "Aspect" | "Property" | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Weapon">;
+    getInstanceById: GetInstanceById<"Publication" | "Subject" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "TradeSecret" | "Aspect" | "Property" | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Weapon" | "Patron">;
     getAllInstances: GetAllInstances<"Script">;
     getResolvedSelectOptionById: GetResolvedSelectOptionById;
     getAllResolvedSelectOptions: GetAllResolvedSelectOptions;
     getAllResolvedNewSkillApplications: GetAllResolvedNewSkillApplications;
     getAllResolvedSkillUses: GetAllResolvedSkillUses;
 }, import("../index.js").EntityDescription>;
+export {};

package/lib/entities/activatable.js

@@ -1,3 +1,6 @@
+import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
+import { count } from "@elyukai/utils/array/reductions";
+import { deepEqual } from "@elyukai/utils/equality";
 import { on } from "@elyukai/utils/function";
 import { isNotNullish } from "@elyukai/utils/nullable";
 import { numAsc } from "@optolith/helpers/compare";
@@ -7,14 +10,25 @@ import { romanize } from "@optolith/helpers/roman";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { Case, fromUniformCase } from "tsondb/schema/gen";
 import { createEntityDescriptionCreator } from "../creator.js";
+import { renderActivatableNameComponents } from "./partial/activatableNameChunks.js";
 import { renderAdventurePointsValue } from "./partial/adventurePointsValue.js";
 import { renderResponsiveMap } from "./partial/map.js";
+import { attributedName } from "./partial/markdown.js";
 import { additionFormatter } from "./partial/mathOperation.js";
 import { printAdvantageDisadvantagePrerequisites, printGeneralPrerequisites, } from "./partial/prerequisites/index.js";
+import { printActivatableName, } from "./partial/prerequisites/single/activatable.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
 import { getResponsiveText, getResponsiveTextOptional, ResponsiveTextSize, } from "./partial/responsiveText.js";
 import { formatTimeSpan } from "./partial/units/timeSpan.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
+const isStyleSpecialAbilityKind = (value) => value === "SkillStyleSpecialAbility" ||
+    value === "CombatStyleSpecialAbility" ||
+    value === "MagicStyleSpecialAbility" ||
+    value === "LiturgicalStyleSpecialAbility";
+const isAdvancedSpecialAbilityKind = (value) => value === "AdvancedSkillSpecialAbility" ||
+    value === "AdvancedCombatSpecialAbility" ||
+    value === "AdvancedMagicalSpecialAbility" ||
+    value === "AdvancedKarmaSpecialAbility";
 const renderPropertyValue = (getInstanceById, translate, translateMap, propertyDecl) => {
     switch (propertyDecl.kind) {
         case "DependingOnSelection":
@@ -129,7 +143,7 @@ const wrapInParens = (args, append = "") => {
     return ` (${filteredArgs.join(", ") + append})`;
 };
 const addSpaceIfNoCommaAtStart = (str) => (str.startsWith(",") ? str : ` ${str}`);
-const renderApplicableCombatTechniquesRestriction = (getInstanceById, locale, main, restriction, translation, weapons, getExcludedInstance) => {
+const renderApplicableCombatTechniquesRestriction = (getInstanceById, locale, main, restriction, translation, weapons, normalizeExcludedId) => {
     switch (restriction.kind) {
         case "Improvised":
             return main + wrapInParens([locale.translate("only improvised weapons"), weapons]);
@@ -143,13 +157,12 @@ const renderApplicableCombatTechniquesRestriction = (getInstanceById, locale, ma
                 return main + wrapInParens([weapons], locale.translate("while mounted"));
             }
         case "Race": {
-            const race = getInstanceById("Race", restriction.Race);
-            const raceName = locale.translateMap(race?.translations)?.name ?? MISSING_VALUE;
+            const raceName = attributedName(locale.translateMap, getInstanceById, "applicable-combat-technique", "Race", restriction.Race);
             return (main +
                 wrapInParens([
                     // originally "while {$racial} weapon", but different to parameterize without inflection support
                     locale.translate("while weapon of race {$race}", {
-                        race: raceName,
+                        race: raceName ?? MISSING_VALUE,
                     }),
                     weapons,
                 ]));
@@ -159,7 +172,12 @@ const renderApplicableCombatTechniquesRestriction = (getInstanceById, locale, ma
                 wrapInParens([
                     locale.translate("except {$list}", {
                         list: locale.join(restriction.ExcludeCombatTechniques.list
-                            .map(id => locale.translateMap(getExcludedInstance?.(id)?.translations)?.name ?? MISSING_VALUE)
+                            .map(id => {
+                            const normalizedId = normalizeExcludedId?.(id);
+                            return normalizedId !== undefined
+                                ? (attributedName(locale.translateMap, getInstanceById, "applicable-combat-technique", normalizedId) ?? MISSING_VALUE)
+                                : MISSING_VALUE;
+                        })
                             .toSorted(locale.compare), "conjunction"),
                     }),
                     weapons,
@@ -194,28 +212,27 @@ const renderApplicableCombatTechniquesValue = (getInstanceById, locale, translat
             const main = locale.translate("All");
             const mainWithRestriction = applicableCombatTechniques.All.restriction === undefined
                 ? main
-                : renderApplicableCombatTechniquesRestriction(getInstanceById, locale, main, applicableCombatTechniques.All.restriction, translation, undefined, id => getInstanceById(id.kind, fromUniformCase(id)));
+                : renderApplicableCombatTechniquesRestriction(getInstanceById, locale, main, applicableCombatTechniques.All.restriction, translation, undefined, id => id);
             return mainWithRestriction;
         }
         case "AllClose": {
             const main = locale.translate("All Close Combat Techniques");
             const mainWithRestriction = applicableCombatTechniques.AllClose.restriction === undefined
                 ? main
-                : renderApplicableCombatTechniquesRestriction(getInstanceById, locale, main, applicableCombatTechniques.AllClose.restriction, translation, undefined, id => getInstanceById("CloseCombatTechnique", id));
+                : renderApplicableCombatTechniquesRestriction(getInstanceById, locale, main, applicableCombatTechniques.AllClose.restriction, translation, undefined, id => Case("CloseCombatTechnique", id));
             return mainWithRestriction;
         }
         case "AllRanged": {
             const main = locale.translate("All Ranged Combat Techniques");
             const mainWithRestriction = applicableCombatTechniques.AllRanged.restriction === undefined
                 ? main
-                : renderApplicableCombatTechniquesRestriction(getInstanceById, locale, main, applicableCombatTechniques.AllRanged.restriction, translation, undefined, id => getInstanceById("RangedCombatTechnique", id));
+                : renderApplicableCombatTechniquesRestriction(getInstanceById, locale, main, applicableCombatTechniques.AllRanged.restriction, translation, undefined, id => Case("RangedCombatTechnique", id));
             return mainWithRestriction;
         }
         case "Specific": {
             return applicableCombatTechniques.Specific.list
                 .map(specific => {
-                const entry = getInstanceById(specific.id.kind, fromUniformCase(specific.id));
-                const main = locale.translateMap(entry?.translations)?.name ?? MISSING_VALUE;
+                const main = attributedName(locale.translateMap, getInstanceById, "applicable-combat-technique", specific.id) ?? MISSING_VALUE;
                 const mainWithRestriction = specific.restriction === undefined
                     ? main
                     : renderApplicableCombatTechniquesRestriction(getInstanceById, locale, main, specific.restriction, translation, specific.weapons === undefined
@@ -460,6 +477,155 @@ const renderCost = (translate, translateMap, localeJoin, localeCompare, getAllRe
             return assertExhaustive(cost);
     }
 };
+const renderAdvancedLabel = (translate, entityName) => {
+    switch (entityName) {
+        case "SkillStyleSpecialAbility":
+            return translate("Advanced Skill Special Abilities");
+        case "CombatStyleSpecialAbility":
+            return translate("Advanced Combat Special Abilities");
+        case "MagicStyleSpecialAbility":
+            return translate("Advanced Magical Special Abilities");
+        case "LiturgicalStyleSpecialAbility":
+            return translate("Advanced Karma Special Abilities");
+        default:
+            return assertExhaustive(entityName);
+    }
+};
+const normalizeId = (entityName, id) => {
+    if (typeof id === "string") {
+        switch (entityName) {
+            case "SkillStyleSpecialAbility":
+                return Case("AdvancedSkillSpecialAbility", id);
+            case "CombatStyleSpecialAbility":
+                return Case("AdvancedCombatSpecialAbility", id);
+            case "MagicStyleSpecialAbility":
+                return Case("AdvancedMagicalSpecialAbility", id);
+            case "LiturgicalStyleSpecialAbility":
+                return Case("AdvancedKarmaSpecialAbility", id);
+            default:
+                return assertExhaustive(entityName);
+        }
+    }
+    else {
+        return id;
+    }
+};
+const renderAdvancedSpecialAbilityName = (translate, translateMap, getInstanceById, getResolvedSelectOptionById, entityName, id, option) => {
+    const normalizedId = normalizeId(entityName, id);
+    return `^[${mapNullable(printActivatableName(getInstanceById, translate, normalizedId, option, undefined, getResolvedSelectOptionById, false), name => renderActivatableNameComponents(translateMap, name, false)) ?? MISSING_VALUE}](entity: "${normalizedId.kind}", instance: "${fromUniformCase(normalizedId)}", style: "normal")`;
+};
+const renderAdvancedValue = (translate, translateMap, localeJoin, getInstanceById, getResolvedSelectOptionById, entityName, advanced) => {
+    if (advanced.every(entry => entry.kind === "OneOf") &&
+        isNotEmpty(advanced) &&
+        advanced.every(entry => entry.OneOf.options.length === 3)) {
+        const optionsInAllEntries = advanced[0].OneOf.options.filter(option => advanced.every(otherEntry => otherEntry.OneOf.options.some(otherOption => deepEqual(option, otherOption))));
+        if (optionsInAllEntries.length === 2) {
+            const uniqueOptions = advanced
+                .map(entry => entry.OneOf.options.find(option => optionsInAllEntries.every(commonOption => !deepEqual(option, commonOption))))
+                .filter(isNotNullish); // should not do anything, just for type narrowing
+            if (uniqueOptions.length === advanced.length) {
+                const [first, second] = optionsInAllEntries.map(option => renderAdvancedSpecialAbilityName(translate, translateMap, getInstanceById, getResolvedSelectOptionById, entityName, option));
+                return [
+                    ...uniqueOptions.map(option => renderAdvancedSpecialAbilityName(translate, translateMap, getInstanceById, getResolvedSelectOptionById, entityName, option)),
+                    translate("one or two of these special abilities can alternatively be replaced by advanced special abilities {$first} and/or {$second}", { first, second }),
+                ].join(", ");
+            }
+        }
+    }
+    const derivedFromExternalOptionEntriesToGenerate = count(advanced, entry => entry.kind === "DeriveFromExternalOption" &&
+        entry.DeriveFromExternalOption.display_option === undefined);
+    return [
+        ...advanced.map((entry) => {
+            switch (entry.kind) {
+                case "General":
+                    return renderAdvancedSpecialAbilityName(translate, translateMap, getInstanceById, getResolvedSelectOptionById, entityName, entry.General);
+                case "RestrictOptions":
+                    return renderAdvancedSpecialAbilityName(translate, translateMap, getInstanceById, getResolvedSelectOptionById, entityName, entry.RestrictOptions.id, entry.RestrictOptions.option);
+                case "OneOf": {
+                    if (entry.OneOf.display_option !== undefined) {
+                        switch (entry.OneOf.display_option.kind) {
+                            case "Hide":
+                                return undefined;
+                            case "ReplaceWith":
+                                return (translateMap(entry.OneOf.display_option.ReplaceWith.translations)?.replacement ??
+                                    MISSING_VALUE);
+                            default:
+                                return assertExhaustive(entry.OneOf.display_option);
+                        }
+                    }
+                    return localeJoin(entry.OneOf.options.map(option => renderAdvancedSpecialAbilityName(translate, translateMap, getInstanceById, getResolvedSelectOptionById, entityName, option)), "disjunction");
+                }
+                case "DeriveFromExternalOption":
+                    if (entry.DeriveFromExternalOption.display_option !== undefined) {
+                        switch (entry.DeriveFromExternalOption.display_option.kind) {
+                            case "Hide":
+                                return undefined;
+                            case "ReplaceWith":
+                                return (translateMap(entry.DeriveFromExternalOption.display_option.ReplaceWith.translations)?.replacement ?? MISSING_VALUE);
+                            default:
+                                return assertExhaustive(entry.DeriveFromExternalOption.display_option);
+                        }
+                    }
+                    return undefined;
+                default:
+                    return assertExhaustive(entry);
+            }
+        }),
+        derivedFromExternalOptionEntriesToGenerate === 0
+            ? undefined
+            : translate(".input {$count :number} {{{$count} more by primary patron}}", {
+                count: derivedFromExternalOptionEntriesToGenerate,
+            }),
+    ]
+        .filter(isNotNullish)
+        .join(", ");
+};
+const renderDeriveFromExternalOptionTable = (translate, translateMap, localeCompare, getInstanceById, getResolvedSelectOptionById, entityName, advanced) => {
+    if (!isStyleSpecialAbilityKind(entityName)) {
+        return undefined;
+    }
+    const derivedFromExternalOptionEntriesToGenerate = advanced.filter((entry) => entry.kind === "DeriveFromExternalOption" &&
+        entry.DeriveFromExternalOption.display_option === undefined);
+    if (derivedFromExternalOptionEntriesToGenerate.length === 0) {
+        return undefined;
+    }
+    const rows = Map.groupBy(derivedFromExternalOptionEntriesToGenerate.flatMap(entry => entry.DeriveFromExternalOption.map.map((option) => [
+        option.from_option,
+        option.to_advanced,
+    ])), row => row[0])
+        .entries()
+        .map(([option, list]) => [
+        translateMap(getInstanceById("Patron", option)?.translations)?.name ?? MISSING_VALUE,
+        list
+            .map(([, toAdvanced]) => renderAdvancedSpecialAbilityName(translate, translateMap, getInstanceById, getResolvedSelectOptionById, entityName, toAdvanced))
+            .toSorted(localeCompare)
+            .join(", "),
+    ])
+        .toArray()
+        .toSorted(on(row => row[0], localeCompare));
+    return {
+        type: "table",
+        header: [translate("Patron"), renderAdvancedLabel(translate, entityName)],
+        rows,
+    };
+};
+const renderTrailingAdvancedPrerequisitesNote = (translate, entityName) => {
+    if (isAdvancedSpecialAbilityKind(entityName)) {
+        switch (entityName) {
+            case "AdvancedCombatSpecialAbility":
+                return translate("corresponding combat style special ability");
+            case "AdvancedKarmaSpecialAbility":
+                return translate("corresponding liturgical style special ability");
+            case "AdvancedMagicalSpecialAbility":
+                return translate("corresponding magic style special ability");
+            case "AdvancedSkillSpecialAbility":
+                return translate("corresponding skill style special ability");
+            default:
+                return assertExhaustive(entityName);
+        }
+    }
+    return undefined;
+};
 /**
  * Get a JSON representation of the rules text for a special ability.
  */
@@ -473,9 +639,8 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
     const baseEntry = entry;
     const wrappedId = Case(entityName, id);
     return {
-        title: translation.name_in_library ??
-            translation.name +
-                (baseEntry.levels !== undefined ? ` I–${romanize(baseEntry.levels)}` : ""),
+        title: (translation.name_in_library ?? translation.name) +
+            (baseEntry.levels !== undefined ? ` I–${romanize(baseEntry.levels)}` : ""),
         subtitle: mapNullable(baseEntry.usage_type, usageType => {
             switch (usageType.kind) {
                 case "Passive":
@@ -526,18 +691,24 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
                         label: translate("Range"),
                         value: range,
                     })),
+                    mapNullable(baseEntry.advanced, advanced => isStyleSpecialAbilityKind(entityName)
+                        ? {
+                            label: renderAdvancedLabel(translate, entityName),
+                            value: renderAdvancedValue(translate, translateMap, locale.join, getInstanceById, getResolvedSelectOptionById, entityName, advanced),
+                        }
+                        : undefined),
                     mapNullable(baseEntry.penalty, penalty => ({
                         label: translate("Penalty"),
                         value: renderPenaltyValue(getInstanceById, translate, translateMap, translation.name, penalty),
                     })),
-                    mapNullable(entry.prerequisites, prerequisites => ({
+                    mapNullable(entry.prerequisites ?? (isAdvancedSpecialAbilityKind(entityName) ? [] : undefined), prerequisites => ({
                         label: translate("Prerequisites"),
                         value: wrappedId.kind === "Advantage" || wrappedId.kind === "Disadvantage"
                             ? printAdvantageDisadvantagePrerequisites(getInstanceById, getResolvedSelectOptionById, locale, prerequisites, translation.name, wrappedId.kind)
                             : printGeneralPrerequisites(getInstanceById, getResolvedSelectOptionById, locale, prerequisites, mapNullable(baseEntry.levels, levels => ({
                                 id: wrappedId,
                                 levels,
-                            }))),
+                            })), renderTrailingAdvancedPrerequisitesNote(translate, entityName)),
                     })),
                     mapNullable(baseEntry.combat_techniques, combatTechniques => ({
                         label: translate("Combat Techniques"),
@@ -573,6 +744,7 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
                     }),
                 ],
             },
+            renderDeriveFromExternalOptionTable(translate, translateMap, locale.compare, getInstanceById, getResolvedSelectOptionById, entityName, baseEntry.advanced ?? []),
         ],
         errata: translation.errata,
         references: entry.src,

package/lib/entities/curriculum.js

@@ -5,6 +5,7 @@ import { sign } from "@elyukai/utils/string/number";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { isNotNullish, mapNullable } from "@optolith/helpers/nullable";
 import { createEntityDescriptionCreator } from "../creator.js";
+import { attributedName } from "./partial/markdown.js";
 import { getBaseProfessionPackageForCurriculum } from "./partial/professions.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
@@ -14,13 +15,12 @@ const renderElectiveSpellworks = (translate, translateMap, localeCompare, getIns
             return translate("All, at the GM’s discretion");
         case "Specific":
             return electiveSpellworks.Specific.list
-                .map(item => mapNullable(translateMap(getInstanceById(item.id)?.translations)?.name, name => {
+                .map(item => mapNullable(attributedName(translateMap, getInstanceById, "curriculum", item.id), name => {
                 if (item.restriction === undefined) {
                     return name;
                 }
                 return (name +
-                    parensIf(translateMap(getInstanceById("Element", item.restriction.Element)?.translations)
-                        ?.name ?? MISSING_VALUE));
+                    parensIf(attributedName(translateMap, getInstanceById, "curriculum", "Element", item.restriction.Element)));
             }))
                 .filter(isNotNullish)
                 .toSorted(localeCompare)
@@ -42,7 +42,7 @@ const renderRestrictedSpellworks = (translate, translateMap, localeCompare, loca
             return "";
         }
         const translatedSpellworks = excludedSpellworks
-            .map(excludedSpellwork => translateMap(getInstanceById(excludedSpellwork)?.translations)?.name)
+            .map(excludedSpellwork => attributedName(translateMap, getInstanceById, "curriculum", excludedSpellwork))
             .filter(isNotNullish);
         if (translatedSpellworks.length === 0) {
             return "";
@@ -53,16 +53,14 @@ const renderRestrictedSpellworks = (translate, translateMap, localeCompare, loca
     };
     const restrictedProperties = restrictedGroups.get("restrictedProperty")?.map(restriction => translate(".input {$count :number} {{only {$count} additional spellworks with the Property {$property}}}", {
         count: restriction.Property.maximum,
-        property: translateMap(getInstanceById("Property", restriction.Property.id)?.translations)
-            ?.name ?? MISSING_VALUE,
+        property: attributedName(translateMap, getInstanceById, "curriculum", "Property", restriction.Property.id) ?? MISSING_VALUE,
     }) + addExclusion(restriction.Property.exclude)) ?? [];
     const propertyGroup = restrictedGroups.get("property");
     const translatedProperties = propertyGroup
         ?.map(restriction => {
         switch (restriction.kind) {
             case "Property":
-                return translateMap(getInstanceById("Property", restriction.Property.id)?.translations)
-                    ?.name;
+                return attributedName(translateMap, getInstanceById, "curriculum", "Property", restriction.Property.id);
             case "DemonSummoning":
                 return translate("Demon Summoning");
             default:
@@ -80,7 +78,7 @@ const renderRestrictedSpellworks = (translate, translateMap, localeCompare, loca
         : [];
     const spellworkGroup = restrictedGroups.get("spellwork");
     const translatedSpellworks = spellworkGroup
-        ?.map(restriction => translateMap(getInstanceById(restriction.Spellwork)?.translations)?.name)
+        ?.map(restriction => attributedName(translateMap, getInstanceById, "curriculum", restriction.Spellwork))
         .filter(isNotNullish)
         .toSorted(localeCompare) ?? [];
     const spellworks = translatedSpellworks.length > 0
@@ -103,24 +101,20 @@ const renderRestrictedSpellworks = (translate, translateMap, localeCompare, loca
     }) ?? [];
     return [...restrictedProperties, ...properties, ...others, ...spellworks].join("; ");
 };
-const renderSpellworkAdjustment = (translateMap, getInstanceById, adjustment) => `${translateMap(getInstanceById(adjustment.id)?.translations)?.name ?? MISSING_VALUE} ${adjustment.points.toFixed()}${parensIf(adjustment.tradition === undefined
+const renderSpellworkAdjustment = (translateMap, getInstanceById, adjustment) => `${attributedName(translateMap, getInstanceById, "curriculum", adjustment.id) ?? MISSING_VALUE} ${adjustment.points.toFixed()}${parensIf(adjustment.tradition === undefined
     ? undefined
-    : translateMap(getInstanceById("MagicalTradition", adjustment.tradition)?.translations)?.name)}`;
+    : attributedName(translateMap, getInstanceById, "curriculum", "MagicalTradition", adjustment.tradition))}`;
 const renderAbilityAdjustmentName = (translateMap, getInstanceById, abilityAdjustment) => {
     switch (abilityAdjustment.kind) {
         case "Skill":
-            return (translateMap(getInstanceById("Skill", abilityAdjustment.Skill.id)?.translations)?.name ??
-                MISSING_VALUE);
+            return (attributedName(translateMap, getInstanceById, "curriculum", "Skill", abilityAdjustment.Skill.id) ?? MISSING_VALUE);
         case "CombatTechnique":
-            return (translateMap(getInstanceById(abilityAdjustment.CombatTechnique.id)?.translations)?.name ??
-                MISSING_VALUE);
+            return (attributedName(translateMap, getInstanceById, "curriculum", abilityAdjustment.CombatTechnique.id) ?? MISSING_VALUE);
         case "Spellwork":
-            return ((translateMap(getInstanceById(abilityAdjustment.Spellwork.id)?.translations)?.name ??
-                MISSING_VALUE) +
+            return ((attributedName(translateMap, getInstanceById, "curriculum", abilityAdjustment.Spellwork.id) ?? MISSING_VALUE) +
                 parensIf(abilityAdjustment.Spellwork.tradition === undefined
                     ? undefined
-                    : translateMap(getInstanceById("MagicalTradition", abilityAdjustment.Spellwork.tradition)
-                        ?.translations)?.name));
+                    : attributedName(translateMap, getInstanceById, "curriculum", "MagicalTradition", abilityAdjustment.Spellwork.tradition)));
         default:
             return assertExhaustive(abilityAdjustment);
     }
@@ -195,8 +189,7 @@ export const getCurriculumEntityDescription = createEntityDescriptionCreator(({
                 items: [
                     {
                         label: translate("Guideline"),
-                        value: translateMap(getInstanceById("Guideline", entry.guideline)?.translations)?.name ??
-                            MISSING_VALUE,
+                        value: attributedName(translateMap, getInstanceById, "curriculum", "Guideline", entry.guideline) ?? MISSING_VALUE,
                     },
                     {
                         label: translate("Elective Spellworks Package"),

package/lib/entities/derivedCharacteristic.js

@@ -1,21 +1,19 @@
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { createEntityDescriptionCreator } from "../creator.js";
+import { attributedCustomName } from "./partial/markdown.js";
 import { renderMathOperation } from "./partial/mathOperation.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
-const getAttribute = (getInstanceById, translateMap, attributeId, style = "full") => {
-    const attribute = getInstanceById("Attribute", attributeId);
-    if (attribute === undefined) {
-        return MISSING_VALUE;
-    }
+const renderAttributeNameForStyle = (style, translation) => {
     switch (style) {
         case "full":
-            return translateMap(attribute.translations)?.name ?? MISSING_VALUE;
+            return translation.name;
         case "compact":
-            return translateMap(attribute.translations)?.abbreviation ?? MISSING_VALUE;
+            return translation.abbreviation;
         default:
             return assertExhaustive(style);
     }
 };
+const getAttribute = (getInstanceById, translateMap, attributeId, style = "full") => attributedCustomName(translateMap, getInstanceById, "derived-characteristic-calculation", translation => renderAttributeNameForStyle(style, translation), "Attribute", attributeId) ?? MISSING_VALUE;
 const getRaceBaseValue = (translate, translateMap, getInstanceById, idMap, raceBaseValue, style = "full") => {
     const instance = getInstanceById("DerivedCharacteristic", idMap.DerivedCharacteristic[raceBaseValue.kind]);
     const translation = translateMap(instance?.translations);

package/lib/entities/equipmentPackage.js

@@ -2,6 +2,7 @@ import { on } from "@elyukai/utils/function";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { getEquipmentName } from "./equipment.js";
+import { attributedInstance } from "./partial/markdown.js";
 const sumAtomicEquipmentCost = (acc, current) => {
     if (typeof acc === "string") {
         return acc;
@@ -280,7 +281,7 @@ export const getEquipmentPackageEntityDescription = createEntityDescriptionCreat
                 header: [translation.name, translate("Weight"), translate("Cost")],
                 rows: actualItems
                     .map((item) => [
-                    getEquipmentName(translate, translateMap, getInstanceById, item.content),
+                    attributedInstance(getEquipmentName(translate, translateMap, getInstanceById, item.content), item.content.entity, item.content.id, { context: '"equipment-package"' }),
                     renderAtomicWeight(translate, locale.measurementAdjustments, getAtomicEquipmentWeight(item.content)),
                     renderAtomicCost(translate, getAtomicEquipmentCost(item.content)),
                 ])

package/lib/entities/liturgicalChant.js

@@ -3,6 +3,7 @@ import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { Case } from "tsondb/schema/gen";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderEnhancements } from "./partial/enhancements.js";
+import { attributedInstance, attributedName } from "./partial/markdown.js";
 import { renderOneTimeDuration } from "./partial/rated/activatable/duration.js";
 import { renderEffect } from "./partial/rated/activatable/effect.js";
 import { combineGeneratedTextWithStaticTranslation, renderFastPerformanceParameters, renderSlowPerformanceParameters, } from "./partial/rated/activatable/index.js";
@@ -13,7 +14,7 @@ import { renderImprovementCost } from "./partial/rated/improvementCost.js";
 import { renderSkillCheckWithPenalty } from "./partial/rated/skillCheck.js";
 import { ResponsiveTextSize } from "./partial/responsiveText.js";
 const getTextForTraditions = (deps, values) => {
-    const getAspectName = (aspectId) => deps.translateMap(deps.getInstanceById("Aspect", aspectId)?.translations)?.name;
+    const getAspectName = (aspectId) => attributedName(deps.translateMap, deps.getInstanceById, "traditions", "Aspect", aspectId);
     const text = values
         .map(trad => {
         switch (trad.kind) {
@@ -25,14 +26,17 @@ const getTextForTraditions = (deps, values) => {
                 if (name === undefined) {
                     return undefined;
                 }
+                const attributedStringName = attributedInstance(name, "BlessedTradition", trad.Tradition.tradition, {
+                    context: '"traditions"',
+                });
                 const aspects = trad.Tradition.aspects
                     ?.map(getAspectName)
                     .filter(isNotNullish)
                     .sort(deps.localeCompare) ?? [];
                 if (aspects.length === 0) {
-                    return name;
+                    return attributedStringName;
                 }
-                return `${name} (${aspects.join(" and ")})`;
+                return `${attributedStringName} (${aspects.join(" and ")})`;
             }
             default:
                 return assertExhaustive(trad);

package/lib/entities/partial/commonnessRatedAdvantagesAndDisadvantages.js

@@ -2,18 +2,17 @@ import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { mapNullable } from "@elyukai/utils/nullable";
 import { Reader } from "@elyukai/utils/reader";
 import { ensureNonEmpty } from "@optolith/helpers/array";
+import { attributedCustomName } from "./markdown.js";
 import { parensIf } from "./rated/activatable/parensIf.js";
 import { MISSING_VALUE } from "./unknown.js";
 const renderCommonnessRatedAdvantageOrDisadvantageName = (translateMap, getInstanceById, entity, item) => {
-    const instance = getInstanceById(entity, item.id);
-    const instanceTranslation = translateMap(instance?.translations);
     const customTranslation = translateMap(item.translations);
-    const name = instanceTranslation?.name_in_library ?? instanceTranslation?.name;
-    return name !== undefined &&
-        customTranslation?.options !== undefined &&
-        name.endsWith(")")
-        ? `${name.slice(0, -1)}; ${customTranslation.options})`
-        : (name ?? MISSING_VALUE) + parensIf(customTranslation?.options);
+    return (attributedCustomName(translateMap, getInstanceById, entity, translation => {
+        const name = translation.name_in_library ?? translation.name;
+        return customTranslation?.options !== undefined && name.endsWith(")")
+            ? `${name.slice(0, -1)}; ${customTranslation.options})`
+            : name + parensIf(customTranslation?.options);
+    }, entity, item.id) ?? MISSING_VALUE);
 };
 /**
  * Render the names of either commonness-rated advantages or commonness-rated disadvantages.
@@ -27,10 +26,7 @@ export const renderCommonnessRatedAdvantagesOrDisadvantages = (entity, items) =>
 /**
  * Render the names of commonness-rated advantages and disadvantages together.
  */
-export const renderCommonnessRatedAdvantagesAndDisadvantages = (advantages, disadvantages) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => mapNullable(ensureNonEmpty([
-    ["Advantage", advantages],
-    ["Disadvantage", disadvantages],
-].flatMap(([entity, items]) => items?.map(item => renderCommonnessRatedAdvantageOrDisadvantageName(translateMap, getInstanceById, entity, item)) ?? [])), renderedItems => renderedItems.toSorted(localeCompare).join(", ")) ?? translate("none"));
+export const renderCommonnessRatedAdvantagesAndDisadvantages = (advantages, disadvantages) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => mapNullable(ensureNonEmpty([["Advantage", advantages], ["Disadvantage", disadvantages]].flatMap(([entity, items]) => items?.map(item => renderCommonnessRatedAdvantageOrDisadvantageName(translateMap, getInstanceById, entity, item)) ?? [])), renderedItems => renderedItems.toSorted(localeCompare).join(", ")) ?? translate("none"));
 /**
  * Render a value with a possible translation, falling back to explicity rendering the value if no translation is available.
  */

package/lib/entities/partial/herbary.js

@@ -1,6 +1,7 @@
 import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { renderDice } from "./dice.js";
+import { attributedName } from "./markdown.js";
 import { parensIf } from "./rated/activatable/parensIf.js";
 import { MISSING_VALUE } from "./unknown.js";
 /**
@@ -24,16 +25,12 @@ export const renderLaboratoryLevel = (translate, level) => {
 export const renderResistance = (translate, translateMap, getInstanceById, idMap, resistance) => {
     switch (resistance.kind) {
         case "Spirit":
-            return (translateMap(getInstanceById("DerivedCharacteristic", idMap.DerivedCharacteristic.Spirit)
-                ?.translations)?.name ?? MISSING_VALUE);
+            return (attributedName(translateMap, getInstanceById, "resistance", "DerivedCharacteristic", idMap.DerivedCharacteristic.Spirit) ?? MISSING_VALUE);
         case "Toughness":
-            return (translateMap(getInstanceById("DerivedCharacteristic", idMap.DerivedCharacteristic.Toughness)
-                ?.translations)?.name ?? MISSING_VALUE);
+            return (attributedName(translateMap, getInstanceById, "resistance", "DerivedCharacteristic", idMap.DerivedCharacteristic.Toughness) ?? MISSING_VALUE);
         case "LowerOfSpiritAndToughness": {
-            const spiritTranslation = translateMap(getInstanceById("DerivedCharacteristic", idMap.DerivedCharacteristic.Spirit)
-                ?.translations)?.name ?? MISSING_VALUE;
-            const toughnessTranslation = translateMap(getInstanceById("DerivedCharacteristic", idMap.DerivedCharacteristic.Toughness)
-                ?.translations)?.name ?? MISSING_VALUE;
+            const spiritTranslation = attributedName(translateMap, getInstanceById, "resistance", "DerivedCharacteristic", idMap.DerivedCharacteristic.Spirit) ?? MISSING_VALUE;
+            const toughnessTranslation = attributedName(translateMap, getInstanceById, "resistance", "DerivedCharacteristic", idMap.DerivedCharacteristic.Toughness) ?? MISSING_VALUE;
             return translate("{$first} or {$second}, depending on which value is lower", {
                 first: spiritTranslation,
                 second: toughnessTranslation,