@optolith/entity-descriptions 0.4.8 → 0.4.10

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 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)
 
 

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
@@ -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.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,

package/lib/entities/partial/markdown.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Some helpers to create Markdown content.
+ */
+import type { EntityMap } from "optolith-database-schema/gen";
+import { type IdArgsVariant } from "tsondb/schema/gen";
+import type { GetInstanceById } from "../../helpers/getTypes.js";
+import type { LocaleMap, TranslateMap } from "../../helpers/translate.js";
+/**
+ * Creates an attributed string in Markdown format.
+ */
+export declare const attributedString: (text: string, rawAttributes: Partial<Record<string, string>>) => string;
+/**
+ * Display an instance of an entity in Markdown format.
+ */
+export declare const attributedInstance: (name: string, entity: string, id?: string, other?: Record<string, string>) => string;
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export declare const attributedName: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} ? K : never; }[keyof EntityMap]>(translateMap: TranslateMap, getInstanceById: GetInstanceById<E>, context: string, ...args: IdArgsVariant<EntityMap, E>) => string | undefined;
+/**
+ * Renders the name of an instance according to a custom function.
+ */
+export declare const customName: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<object>;
+} ? K : never; }[keyof EntityMap]>(translateMap: TranslateMap, getInstanceById: GetInstanceById<E>, fn: (translation: EntityMap[E]["translations"][string]) => string, ...args: IdArgsVariant<EntityMap, E>) => string | undefined;
+/**
+ * Renders the name of an instance according to a custom function in an attributed string.
+ */
+export declare const attributedCustomName: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<object>;
+} ? K : never; }[keyof EntityMap]>(translateMap: TranslateMap, getInstanceById: GetInstanceById<E>, context: string, fn: (translation: EntityMap[E]["translations"][string]) => string, ...args: IdArgsVariant<EntityMap, E>) => string | undefined;
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export declare const attributedNameFromInstance: (translateMap: TranslateMap, instance: {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} | undefined, context: string, ...args: IdArgsVariant<EntityMap, keyof EntityMap>) => string | undefined;
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export declare const attributedNameFromTranslation: (translation: {
+    name: string;
+} | undefined, context: string, ...args: IdArgsVariant<EntityMap, keyof EntityMap>) => string | undefined;
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export declare const attributedNameFromSafeTranslation: (translation: {
+    name: string;
+}, context: string, ...args: IdArgsVariant<EntityMap, keyof EntityMap>) => string;

package/lib/entities/partial/markdown.js

@@ -0,0 +1,59 @@
+/**
+ * Some helpers to create Markdown content.
+ */
+import { mapNullable } from "@elyukai/utils/nullable";
+import { normalizedIdArgs } from "tsondb/schema/gen";
+/**
+ * Creates an attributed string in Markdown format.
+ */
+export const attributedString = (text, rawAttributes) => `^[${text}](${Object.entries(rawAttributes)
+    .filter((pair) => pair[1] !== undefined)
+    .map(([key, value]) => `${key}: ${value}`)
+    .join(", ")})`;
+/**
+ * Display an instance of an entity in Markdown format.
+ */
+export const attributedInstance = (name, entity, id, other) => attributedString(name, {
+    ...other,
+    entity: `"${entity}"`,
+    instance: id === undefined ? undefined : `"${id}"`,
+});
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export const attributedName = (translateMap, getInstanceById, context, ...args) => {
+    const id = normalizedIdArgs(args);
+    return mapNullable(translateMap(getInstanceById(...args)?.translations)?.name, name => attributedInstance(name, id.entityName, id.id, { context: `"${context}"` }));
+};
+/**
+ * Renders the name of an instance according to a custom function.
+ */
+export const customName = (translateMap, getInstanceById, fn, ...args) => mapNullable(translateMap(getInstanceById(...args)?.translations), translation => fn(translation));
+/**
+ * Renders the name of an instance according to a custom function in an attributed string.
+ */
+export const attributedCustomName = (translateMap, getInstanceById, context, fn, ...args) => {
+    const id = normalizedIdArgs(args);
+    return mapNullable(translateMap(getInstanceById(...args)?.translations), translation => attributedInstance(fn(translation), id.entityName, id.id, { context: `"${context}"` }));
+};
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export const attributedNameFromInstance = (translateMap, instance, context, ...args) => {
+    const id = normalizedIdArgs(args);
+    return mapNullable(translateMap(instance?.translations)?.name, name => attributedInstance(name, id.entityName, id.id, { context: `"${context}"` }));
+};
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export const attributedNameFromTranslation = (translation, context, ...args) => {
+    const id = normalizedIdArgs(args);
+    return mapNullable(translation?.name, name => attributedInstance(name, id.entityName, id.id, { context: `"${context}"` }));
+};
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export const attributedNameFromSafeTranslation = (translation, context, ...args) => {
+    const id = normalizedIdArgs(args);
+    return attributedInstance(translation.name, id.entityName, id.id, { context: `"${context}"` });
+};

package/lib/entities/partial/prerequisites/index.js

@@ -85,7 +85,7 @@ const printPrerequisitesForLevels = (printPrerequisite, locale, value, printPrev
             level: i + 2,
             prerequisite: {
                 kind: "Single",
-                Single: printPreviousLevelPrerequisites.createPreerequisite(i + 2),
+                Single: printPreviousLevelPrerequisites.createPrerequisite(i + 1),
             },
         }));
     const groupedByLevel = Map.groupBy([...value, ...previousLevelPrerequisites], prerequisite => prerequisite.level);
@@ -153,7 +153,7 @@ export const printGeneralPrerequisites = (getInstanceById, getResolvedSelectOpti
     ? undefined
     : {
         levels: printPreviousLevelPrerequisites.levels,
-        createPreerequisite: (level) => ({
+        createPrerequisite: (level) => ({
             kind: "Activatable",
             Activatable: {
                 id: printPreviousLevelPrerequisites.id,

package/lib/entities/partial/prerequisites/part.js

@@ -5,6 +5,7 @@ import { compareNumber, reduceCompare } from "@elyukai/utils/ordering";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { fromUniformCase } from "tsondb/schema/gen";
 import { renderActivatableNameComponents, renderActivatableNameComponentsCombinedIfPossible, } from "../activatableNameChunks.js";
+import { attributedInstance } from "../markdown.js";
 /**
  * Type guard for prerequisite parts with a value object.
  */
@@ -18,15 +19,19 @@ const countFurtherToCombined = (part, remainingParts) => {
             remainingParts.length
         : indexHasDifferentBaseValues;
 };
+const wrapActivatableInAttributedString = (text, id) => attributedInstance(text, id.kind, fromUniformCase(id), { context: '"prerequisite"' });
 const joinAdjacentParts = (translateMap, localeCompare, part, remainingParts) => {
     const valuesWithSameBase = remainingParts.slice(0, countFurtherToCombined(part, remainingParts));
     if (valuesWithSameBase.length > 0) {
         return [
-            renderActivatableNameComponentsCombinedIfPossible(translateMap, [part.value, ...valuesWithSameBase.map(p => p.value)], true, list => list.toSorted(localeCompare).join(", ")),
+            wrapActivatableInAttributedString(renderActivatableNameComponentsCombinedIfPossible(translateMap, [part.value, ...valuesWithSameBase.map(p => p.value)], true, list => list.toSorted(localeCompare).join(", ")), part.value.id),
             valuesWithSameBase.length,
         ];
     }
-    return [renderActivatableNameComponents(translateMap, part.value, true), 0];
+    return [
+        wrapActivatableInAttributedString(renderActivatableNameComponents(translateMap, part.value, true), part.value.id),
+        0,
+    ];
 };
 const appendBySentenceType = (previouslyRendered, currentRendered, sentenceType, isLast) => {
     switch (sentenceType?.kind) {
@@ -76,7 +81,7 @@ const appendPrerequisitePartGroup = (previous, translateMap, localeCompare, part
         return parts.reduce((acc, current, i, arr) => appendBySentenceType(acc, (current.label ?? "") +
             (typeof current.value === "string"
                 ? current.value
-                : renderActivatableNameComponents(translateMap, current.value, true)), current.sentenceType, isLast && i === arr.length - 1), previous);
+                : wrapActivatableInAttributedString(renderActivatableNameComponents(translateMap, current.value, true), current.value.id)), current.sentenceType, isLast && i === arr.length - 1), previous);
     }
 };
 /**

package/lib/entities/partial/prerequisites/single/culture.js

@@ -1,3 +1,4 @@
+import { attributedNameFromSafeTranslation } from "../../markdown.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the translation of a culture prerequisite.
@@ -13,7 +14,7 @@ export const printCulturePrerequisite = (getInstanceById, locale, prerequisite)
     }
     return {
         label: `${locale.translate("Culture")} `,
-        value: cultureTranslation.name,
+        value: attributedNameFromSafeTranslation(cultureTranslation, "prerequisite", "Culture", prerequisite.id),
         sentenceType: undefined,
         isMeta: false,
     };

package/lib/entities/partial/prerequisites/single/personalityTrait.js

@@ -1,3 +1,4 @@
+import { attributedNameFromSafeTranslation } from "../../markdown.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the translation of a personality trait prerequisite.
@@ -11,7 +12,7 @@ export const printPersonalityTraitPrerequisite = (getInstanceById, locale, prere
     if (personalityTrait === undefined || personalityTraitTranslation === undefined) {
         return undefined;
     }
-    const name = `${personalityTraitTranslation.name} (${locale.translate("Level {$level}", {
+    const name = `${attributedNameFromSafeTranslation(personalityTraitTranslation, "prerequisite", "PersonalityTrait", prerequisite.id)} (${locale.translate("Level {$level}", {
         level: personalityTrait.level,
     })})`;
     return {

package/lib/entities/partial/prerequisites/single/profession.js

@@ -1,3 +1,4 @@
+import { attributedInstance } from "../../markdown.js";
 import { getProfessionName } from "../../professions.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
@@ -12,7 +13,9 @@ export const printProfessionPrerequisite = (getChildInstancesForInstanceId, loca
         return undefined;
     }
     return {
-        value: professionName,
+        value: attributedInstance(professionName, "Profession", prerequisite.id, {
+            context: '"prerequisite"',
+        }),
         sentenceType: undefined,
         isMeta: false,
     };

package/lib/entities/partial/prerequisites/single/race.js

@@ -1,3 +1,4 @@
+import { attributedNameFromSafeTranslation } from "../../markdown.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the translation of a race prerequisite.
@@ -13,7 +14,7 @@ export const printRacePrerequisite = (getInstanceById, locale, prerequisite) =>
     }
     return {
         label: `${locale.translate("Race")} `,
-        value: raceTranslation.name,
+        value: attributedNameFromSafeTranslation(raceTranslation, "prerequisite", "Race", prerequisite.id),
         sentenceType: undefined,
         isMeta: false,
     };