@optolith/entity-descriptions 0.4.8 → 0.4.11

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 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.11](https://github.com/Optolith/entity-descriptions/compare/v0.4.10...v0.4.11) (2026-03-23)
+
+
+### Features
+
+* support schema version 0.42.0 ([80b2eaa](https://github.com/Optolith/entity-descriptions/commit/80b2eaacbcf445cf3222c11b86c1be77b7d973d6))
+
+
+### Bug Fixes
+
+* activatable cost by level separator ([a0119ff](https://github.com/Optolith/entity-descriptions/commit/a0119ffdafcc6027801c0ff7b502c9c65af107dd))
+* render attribute prerequisite as abbreviation ([6f258b1](https://github.com/Optolith/entity-descriptions/commit/6f258b1f6f4fb1c88b09fe9fb2013b180d91fc4b))
+
+## [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)
 
 

package/lib/entities/activatable.js

@@ -13,6 +13,7 @@ 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";
@@ -142,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]);
@@ -156,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,
                 ]));
@@ -172,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,
@@ -207,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
@@ -388,7 +392,7 @@ const renderArcaneEnergyCost = (translate, translateMap, localeJoin, responsiveT
                         cost: translate("{$value} AE", {
                             value: cost.ByLevel.levels.map(level => level.value).join("/"),
                         }),
-                        level: Array.from({ length: cost.ByLevel.levels.length }, (_, index) => romanize(index + 1)),
+                        level: Array.from({ length: cost.ByLevel.levels.length }, (_, index) => romanize(index + 1)).join("/"),
                     });
                 case "Verbose":
                     return cost.ByLevel.levels
@@ -635,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":

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.d.ts

@@ -1,9 +1,7 @@
 import type { GetInstanceById } from "../helpers/getTypes.js";
-import type { IdMap } from "../index.js";
 /**
  * Get a JSON representation of the rules text for a derived characteristic.
  */
 export declare const getDerivedCharacteristicEntityDescription: import("../creator.js").EntityDescriptionCreator<"DerivedCharacteristic", {
     getInstanceById: GetInstanceById<"Publication" | "Attribute" | "DerivedCharacteristic">;
-    idMap: IdMap;
 }, import("../index.js").EntityDescription>;

package/lib/entities/derivedCharacteristic.js

@@ -1,27 +1,20 @@
 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 getRaceBaseValue = (translate, translateMap, getInstanceById, idMap, raceBaseValue, style = "full") => {
-    const instance = getInstanceById("DerivedCharacteristic", idMap.DerivedCharacteristic[raceBaseValue.kind]);
-    const translation = translateMap(instance?.translations);
-    if (translation === undefined) {
-        return MISSING_VALUE;
-    }
+const getAttribute = (getInstanceById, translateMap, attributeId, style = "full") => attributedCustomName(translateMap, getInstanceById, "derived-characteristic-calculation", translation => renderAttributeNameForStyle(style, translation), "Attribute", attributeId) ?? MISSING_VALUE;
+const getRaceBaseValue = (translate, translation, style = "full") => {
     switch (style) {
         case "full":
             return translate("Base {$name} from Race", translation);
@@ -31,14 +24,14 @@ const getRaceBaseValue = (translate, translateMap, getInstanceById, idMap, raceB
             return assertExhaustive(style);
     }
 };
-const renderBaseCalculation = (getInstanceById, translate, translateMap, idMap, calculation, style = "full") => renderMathOperation(calculation, value => {
+const renderBaseCalculation = (getInstanceById, translate, translateMap, translation, calculation, style = "full") => renderMathOperation(calculation, value => {
     switch (value.kind) {
         case "Constant":
             return value.Constant.toFixed();
         case "Attribute":
             return getAttribute(getInstanceById, translateMap, value.Attribute, style);
         case "RaceBaseValue":
-            return getRaceBaseValue(translate, translateMap, getInstanceById, idMap, value.RaceBaseValue, style);
+            return getRaceBaseValue(translate, translation, style);
         case "PrimaryAttribute":
             switch (style) {
                 case "full":
@@ -62,7 +55,7 @@ const renderBaseCalculation = (getInstanceById, translate, translateMap, idMap,
 /**
  * Get a JSON representation of the rules text for a derived characteristic.
  */
-export const getDerivedCharacteristicEntityDescription = createEntityDescriptionCreator(({ getInstanceById, idMap }, { translate, translateMap }, { content: entry }) => {
+export const getDerivedCharacteristicEntityDescription = createEntityDescriptionCreator(({ getInstanceById }, { translate, translateMap }, { content: entry }) => {
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
@@ -82,7 +75,7 @@ export const getDerivedCharacteristicEntityDescription = createEntityDescription
                 items: [
                     {
                         label: translate("Base Value"),
-                        value: renderBaseCalculation(getInstanceById, translate, translateMap, idMap, entry.calculation.base),
+                        value: renderBaseCalculation(getInstanceById, translate, translateMap, translation, entry.calculation.base),
                     },
                 ],
             },

package/lib/entities/disease.js

@@ -25,7 +25,11 @@ export const getDiseaseEntityDescription = createEntityDescriptionCreator(({ get
         return undefined;
     }
     return {
-        title: translation.name,
+        title: translation.name +
+            parensIf(ensureNonEmpty([
+                baseEntry.isChildhoodDisease === true ? translate("childhood disease") : undefined,
+                baseEntry.isMagicalDisease === true ? translate("magical disease") : undefined,
+            ].filter(isNotNullish))?.join(", ")),
         className: "disease",
         body: [
             {

package/lib/entities/elixir.js

@@ -58,16 +58,18 @@ export const getElixirEntityDescription = createEntityDescriptionCreator(({ getI
                         },
                     {
                         label: translate("Quality Levels"),
-                        value: [
-                            {
-                                type: "definitionList",
-                                style: "nested",
-                                items: translation.quality_levels.map((effectForLevel, index) => ({
-                                    label: (index + 1).toFixed(),
-                                    value: effectForLevel,
-                                })),
-                            },
-                        ],
+                        value: translation.quality_levels.kind === "Plain"
+                            ? translation.quality_levels.Plain.text
+                            : [
+                                {
+                                    type: "definitionList",
+                                    style: "nested",
+                                    items: translation.quality_levels.ForEachQualityLevel.qualityLevels.map((effectForLevel, index) => ({
+                                        label: (index + 1).toFixed(),
+                                        value: effectForLevel,
+                                    })),
+                                },
+                            ],
                     },
                 ],
             },

package/lib/entities/equipment.d.ts

@@ -1,6 +1,7 @@
-import type { EquipmentIdentifier, GenMeleeWeapon, GenRangedWeapon, LocaleMeasurementAdjustments } from "optolith-database-schema/gen";
+import type { AmmunitionishIdentifier, EquipmentIdentifier, GenMeleeWeapon, GenRangedWeapon, LocaleMeasurementAdjustments } from "optolith-database-schema/gen";
 import { type TaggedEntity } from "../creator.js";
 import type { GetInstanceById } from "../helpers/getTypes.js";
+import type { LocaleJoin } from "../helpers/locale.js";
 import type { Translate, TranslateMap } from "../helpers/translate.js";
 import type { IdMap, LabeledEntityDescriptionSection, RawEntityDescriptionSectionContent } from "../index.js";
 /**
@@ -10,15 +11,15 @@ export declare const getEquipmentName: (translate: Translate, translateMap: Tran
 /**
  * Render combat values of a melee weapon.
  */
-export declare const renderMeleeWeapon: <Damage>(translate: Translate, translateMap: TranslateMap, getInstanceById: GetInstanceById<"Attribute" | "CloseCombatTechnique" | "Reach">, measurements: Required<LocaleMeasurementAdjustments>, renderDamage: (damage: Damage) => string, closeCombatTechniqueId: string, use: GenMeleeWeapon<Damage>) => LabeledEntityDescriptionSection<RawEntityDescriptionSectionContent>;
+export declare const renderMeleeWeapon: <Damage>(translate: Translate, translateMap: TranslateMap, localeJoin: LocaleJoin, getInstanceById: GetInstanceById<"Attribute" | "CloseCombatTechnique" | "Reach">, measurements: Required<LocaleMeasurementAdjustments>, renderDamage: (damage: Damage) => string, closeCombatTechniqueId: string, use: GenMeleeWeapon<Damage>) => LabeledEntityDescriptionSection<RawEntityDescriptionSectionContent>;
 /**
  * Render combat values of a ranged weapon.
  */
-export declare const renderRangedWeapon: <Damage>(translate: Translate, translateMap: TranslateMap, getInstanceById: GetInstanceById<"RangedCombatTechnique" | "Ammunition">, measurements: Required<LocaleMeasurementAdjustments>, renderDamage: (damage: Damage) => string, rangedCombatTechniqueId: string, use: GenRangedWeapon<Damage>) => LabeledEntityDescriptionSection<RawEntityDescriptionSectionContent>;
+export declare const renderRangedWeapon: <Damage>(translate: Translate, translateMap: TranslateMap, getInstanceById: GetInstanceById<"RangedCombatTechnique" | AmmunitionishIdentifier["kind"]>, measurements: Required<LocaleMeasurementAdjustments>, renderDamage: (damage: Damage) => string, rangedCombatTechniqueId: string, use: GenRangedWeapon<Damage>) => LabeledEntityDescriptionSection<RawEntityDescriptionSectionContent>;
 /**
  * Get a JSON representation of the rules text for equipment.
  */
-export declare const getEquipmentEntityDescription: import("../creator.js").EntityDescriptionCreator<"Weapon" | "Armor" | "Ammunition" | "Animal" | "AnimalCare" | "BandageOrRemedy" | "Book" | "CeremonialItem" | "Clothes" | "ClothingPackage" | "Container" | "EquipmentOfBlessedOnes" | "GemOrPreciousStone" | "IlluminationLightSource" | "IlluminationRefillOrSupply" | "Jewelry" | "Laboratory" | "Liebesspielzeug" | "LuxuryGood" | "MagicalArtifact" | "MusicalInstrument" | "Newspaper" | "OrienteeringAid" | "RopeOrChain" | "Stationery" | "ThievesTool" | "ToolOfTheTrade" | "TravelGearOrTool" | "Vehicle" | "WeaponAccessory" | "WorkingSupernaturalCreature", {
-    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Reach" | "SocialStatus" | "CloseCombatTechnique" | "RangedCombatTechnique" | "MagicalTradition" | "BlessedTradition" | "DerivedCharacteristic" | "Ammunition" | "Race" | "Culture" | "Profession" | "Skill">;
+export declare const getEquipmentEntityDescription: import("../creator.js").EntityDescriptionCreator<"Ammunition" | "Weapon" | "Armor" | "Animal" | "AnimalCare" | "BandageOrRemedy" | "Book" | "CeremonialItem" | "Clothes" | "ClothingPackage" | "Container" | "EquipmentOfBlessedOnes" | "GemOrPreciousStone" | "IlluminationLightSource" | "IlluminationRefillOrSupply" | "Jewelry" | "Laboratory" | "Liebesspielzeug" | "LuxuryGood" | "MagicalArtifact" | "MusicalInstrument" | "Newspaper" | "OrienteeringAid" | "RopeOrChain" | "Stationery" | "ThievesTool" | "ToolOfTheTrade" | "TravelGearOrTool" | "Vehicle" | "WeaponAccessory" | "WorkingSupernaturalCreature", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Reach" | "SocialStatus" | "CloseCombatTechnique" | "RangedCombatTechnique" | "MagicalTradition" | "BlessedTradition" | "DerivedCharacteristic" | AmmunitionishIdentifier["kind"] | "Race" | "Culture" | "Profession" | "Skill">;
     idMap: IdMap;
 }, import("../index.js").EntityDescription>;

package/lib/entities/equipment.js

@@ -1,11 +1,14 @@
 import { ensureNonEmpty, isNotEmpty } from "@elyukai/utils/array/nonEmpty";
+import { on } from "@elyukai/utils/function";
 import { isNotNullish } from "@elyukai/utils/nullable";
+import { compareNumber } from "@elyukai/utils/ordering";
 import { romanize } from "@elyukai/utils/roman";
 import { sign } from "@elyukai/utils/string/number";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { mapNullable } from "@optolith/helpers/nullable";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderDice, renderDiceAndFlat } from "./partial/dice.js";
+import { attributedName, attributedNameFromInstance } from "./partial/markdown.js";
 import { additionFormatter, subtractionFormatter } from "./partial/mathOperation.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
 import { ResponsiveTextSize } from "./partial/responsiveText.js";
@@ -91,9 +94,19 @@ const renderPrimaryAttributeAndDamageThreshold = (translateMap, getInstanceById,
 const renderAttackParryModifier = (attackModifier, parryModifier) => attackModifier === undefined && parryModifier === undefined
     ? "—"
     : `${attackModifier === undefined ? "—" : sign(attackModifier)}/${parryModifier === undefined ? "—" : sign(parryModifier)}`;
-const renderReach = (translateMap, getInstanceById, reach) => reach === undefined
+const renderReach = (translateMap, localeJoin, getInstanceById, reaches) => reaches === undefined
     ? "—"
-    : (translateMap(getInstanceById("Reach", reach)?.translations)?.name ?? MISSING_VALUE);
+    : localeJoin(reaches
+        .map((reach) => {
+        const instance = getInstanceById("Reach", reach);
+        return [
+            instance?.position ?? 0,
+            attributedNameFromInstance(translateMap, instance, "equipment", "Reach", reach) ??
+                MISSING_VALUE,
+        ];
+    })
+        .toSorted(on(e => e[0], compareNumber))
+        .map(e => e[1]), "conjunction");
 const renderLength = (translate, measurements, length) => length === undefined
     ? "—"
     : translate(".input {$value :number} {{{$value} inches}}", {
@@ -102,7 +115,7 @@ const renderLength = (translate, measurements, length) => length === undefined
 /**
  * Render combat values of a melee weapon.
  */
-export const renderMeleeWeapon = (translate, translateMap, getInstanceById, measurements, renderDamage, closeCombatTechniqueId, use) => {
+export const renderMeleeWeapon = (translate, translateMap, localeJoin, getInstanceById, measurements, renderDamage, closeCombatTechniqueId, use) => {
     const combatTechnique = getInstanceById("CloseCombatTechnique", closeCombatTechniqueId);
     const fields = combatTechnique?.special ?? {
         can_parry: { kind: "Prohibited" },
@@ -137,7 +150,7 @@ export const renderMeleeWeapon = (translate, translateMap, getInstanceById, meas
                     ? undefined
                     : {
                         label: translate("Reach"),
-                        value: renderReach(translateMap, getInstanceById, use.reach),
+                        value: renderReach(translateMap, localeJoin, getInstanceById, use.reach),
                     },
                 fields.has_length.kind === "Prohibited"
                     ? undefined
@@ -159,7 +172,7 @@ const renderReloadTime = (translate, reloadTime) => isNotEmpty(reloadTime)
 const renderRangeBrackets = (rangeBrackets) => `${rangeBrackets.close.toFixed()}/${rangeBrackets.medium.toFixed()}/${rangeBrackets.far.toFixed()}`;
 const renderAmmunition = (translateMap, getInstanceById, ammunition) => ammunition === undefined
     ? "—"
-    : (translateMap(getInstanceById("Ammunition", ammunition)?.translations)?.name ?? MISSING_VALUE);
+    : (attributedName(translateMap, getInstanceById, "equipment", ammunition) ?? MISSING_VALUE);
 const renderMeleeDamage = (translate) => (damage) => renderDiceAndFlat(translate, damage.dice, damage.flat);
 /**
  * Render combat values of a ranged weapon.
@@ -713,7 +726,7 @@ export const getEquipmentEntityDescription = createEntityDescriptionCreator(({ g
         className: "equipment",
         body: [
             ...(combatValues?.type === "Weapon"
-                ? Object.entries(combatValues.values.melee_uses ?? {}).map(([combatTechniqueId, use]) => renderMeleeWeapon(translate, translateMap, getInstanceById, locale.measurementAdjustments, renderMeleeDamage(translate), combatTechniqueId, use))
+                ? Object.entries(combatValues.values.melee_uses ?? {}).map(([combatTechniqueId, use]) => renderMeleeWeapon(translate, translateMap, locale.join, getInstanceById, locale.measurementAdjustments, renderMeleeDamage(translate), combatTechniqueId, use))
                 : []),
             ...(combatValues?.type === "Weapon"
                 ? Object.entries(combatValues.values.ranged_uses ?? {}).map(([combatTechniqueId, use]) => renderRangedWeapon(translate, translateMap, getInstanceById, locale.measurementAdjustments, renderRangedDamage(translate), combatTechniqueId, use))

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,