@optolith/entity-descriptions 0.4.8 → 0.4.11

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

@@ -1,4 +1,4 @@
-import type { ActivatableIdentifier, AdvantageDisadvantagePrerequisites, AnimistPowerPrerequisites, ArcaneTraditionPrerequisites, DerivedCharacteristicPrerequisites, EnhancementPrerequisites, GeneralPrerequisites, GeodeRitualPrerequisites, InfluencePrerequisites, LanguagePrerequisites, LiturgyPrerequisites, PersonalityTraitPrerequisites, PlainGeneralPrerequisites, ProfessionPrerequisites, PublicationPrerequisites, RatedIdentifier, SpecialAbilityIdentifier, SpellworkPrerequisites } from "optolith-database-schema/gen";
+import type { ActivatableIdentifier, AdvantageDisadvantagePrerequisites, AnimistPowerPrerequisites, ArcaneTraditionPrerequisites, DerivedCharacteristicPrerequisites, EnhancementPrerequisites, GeneralPrerequisites, GeodeRitualPrerequisites, InfluencePrerequisites, LanguagePrerequisites, LiturgyPrerequisites, PersonalityTraitPrerequisites, PlainGeneralPrerequisites, ProfessionPrerequisites, PublicationPrerequisites, RatedIdentifier, SpellworkPrerequisites } from "optolith-database-schema/gen";
 import type { GetAllChildInstancesForParent, GetInstanceById } from "../../../helpers/getTypes.js";
 import type { LocaleEnvironment } from "../../../helpers/locale.js";
 import type { GetResolvedSelectOptionById } from "./single/activatable.js";
@@ -18,7 +18,7 @@ export declare const printPlainGeneralPrerequisites: (getInstanceById: GetInstan
  * Print general prerequisites as a string.
  */
 export declare const printGeneralPrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: GeneralPrerequisites, printPreviousLevelPrerequisites?: {
-    id: SpecialAbilityIdentifier;
+    id: ActivatableIdentifier;
     levels: number;
 }, trailingText?: string) => string;
 /**
@@ -60,7 +60,7 @@ export declare const printAnimistPowerPrerequisites: (getInstanceById: GetInstan
 /**
  * Print geode ritual prerequisites as a string.
  */
-export declare const printGeodeRitualPrerequisites: (getInstanceById: GetInstanceById<"Influence">, locale: LocaleEnvironment, value: GeodeRitualPrerequisites) => string;
+export declare const printGeodeRitualPrerequisites: (getInstanceById: GetInstanceById<"Influence" | ActivatableIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: GeodeRitualPrerequisites) => string;
 /**
  * Print enhancement prerequisites as a string.
  */

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,
@@ -201,7 +201,7 @@ export const printAnimistPowerPrerequisites = (getInstanceById, locale, value) =
 /**
  * Print geode ritual prerequisites as a string.
  */
-export const printGeodeRitualPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printGeodeRitualPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+export const printGeodeRitualPrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value) => printPlainPrerequisites(prerequisite => printGeodeRitualPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, value);
 /**
  * Print enhancement prerequisites as a string.
  */

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

@@ -54,7 +54,7 @@ export declare const printAnimistPowerPrerequisiteGroup: (getInstanceById: GetIn
 /**
  * Print the translation of a geode ritual prerequisite group.
  */
-export declare const printGeodeRitualPrerequisiteGroup: (getInstanceById: GetInstanceById<"Influence">, locale: LocaleEnvironment, prerequisite: GeodeRitualPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printGeodeRitualPrerequisiteGroup: (getInstanceById: GetInstanceById<"Influence" | ActivatableIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, prerequisite: GeodeRitualPrerequisiteGroup) => PrerequisitePart | undefined;
 /**
  * Print the translation of an enhancement prerequisite group.
  */

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

@@ -241,13 +241,16 @@ printAnimistPowerPrerequisite(getInstanceById, locale, prerequisite.AnimistPower
 /**
  * Print the translation of a geode ritual prerequisite group.
  */
-export const printGeodeRitualPrerequisiteGroup = (getInstanceById, locale, prerequisite) => 
-// switch (prerequisite.tag) {
-//   case "Influence":
-//   default:
-//     return assertExhaustive(prerequisite)
-// }
-printInfluencePrerequisite(getInstanceById, locale, prerequisite.Influence);
+export const printGeodeRitualPrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, locale, prerequisite) => {
+    switch (prerequisite.kind) {
+        case "Activatable":
+            return printActivatablePrerequisite(getInstanceById, getResolvedSelectOptionById, locale, prerequisite.Activatable, false);
+        case "Influence":
+            return printInfluencePrerequisite(getInstanceById, locale, prerequisite.Influence);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
 /**
  * Print the translation of an enhancement prerequisite group.
  */

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,
     };

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

@@ -1,31 +1,6 @@
-import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { attributedCustomName } from "../../markdown.js";
 import { MISSING_VALUE } from "../../unknown.js";
 import { printDisplayOption } from "../displayOption.js";
-const printRatedName = (getInstanceById, translateMap, id) => {
-    switch (id.kind) {
-        case "Attribute":
-            return (translateMap(getInstanceById("Attribute", id.Attribute)?.translations)?.abbreviation ??
-                MISSING_VALUE);
-        case "Skill":
-            return translateMap(getInstanceById("Skill", id.Skill)?.translations)?.name ?? MISSING_VALUE;
-        case "CloseCombatTechnique":
-            return (translateMap(getInstanceById("CloseCombatTechnique", id.CloseCombatTechnique)?.translations)
-                ?.name ?? MISSING_VALUE);
-        case "RangedCombatTechnique":
-            return (translateMap(getInstanceById("RangedCombatTechnique", id.RangedCombatTechnique)?.translations)?.name ?? MISSING_VALUE);
-        case "Spell":
-            return translateMap(getInstanceById("Spell", id.Spell)?.translations)?.name ?? MISSING_VALUE;
-        case "Ritual":
-            return translateMap(getInstanceById("Ritual", id.Ritual)?.translations)?.name ?? MISSING_VALUE;
-        case "LiturgicalChant":
-            return (translateMap(getInstanceById("LiturgicalChant", id.LiturgicalChant)?.translations)?.name ??
-                MISSING_VALUE);
-        case "Ceremony":
-            return (translateMap(getInstanceById("Ceremony", id.Ceremony)?.translations)?.name ?? MISSING_VALUE);
-        default:
-            return assertExhaustive(id);
-    }
-};
 /**
  * Get the translation of a blessed tradition prerequisite.
  */
@@ -34,7 +9,7 @@ export const printRatedPrerequisite = (getInstanceById, locale, prerequisite) =>
         return printDisplayOption(locale.translateMap, prerequisite.display_option);
     }
     return {
-        value: `${printRatedName(getInstanceById, locale.translateMap, prerequisite.id)} ${prerequisite.value.toFixed()}`,
+        value: `${attributedCustomName(locale.translateMap, getInstanceById, "prerequisite", (t) => t.abbreviation ?? t.name, prerequisite.id) ?? MISSING_VALUE} ${prerequisite.value.toFixed()}`,
         sentenceType: undefined,
         isMeta: false,
     };

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

@@ -1,5 +1,6 @@
 import { isNotNullish } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { attributedName } from "../../markdown.js";
 import { MISSING_VALUE } from "../../unknown.js";
 import { printDisplayOption } from "../displayOption.js";
 const printNumberOfTheFollowingSkills = (locale, number) => locale.translate(".input {$count :number} {{{$count} of the following skills}}", {
@@ -36,7 +37,7 @@ export const printRatedMinimumNumberPrerequisite = (getInstanceById, locale, pre
     switch (prerequisite.targets.kind) {
         case "Skills": {
             const skills = prerequisite.targets.Skills.targets
-                .map(id => locale.translateMap(getInstanceById("Skill", id)?.translations)?.name)
+                .map(id => attributedName(locale.translateMap, getInstanceById, "prerequisite", "Skill", id))
                 .filter(isNotNullish);
             return {
                 value: locale.translate(".input {$minRating :number} {{{$count} on at least SR {$minRating}: {$list}}}", // zwei der folgenden Talente mindestens FW 10:

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

@@ -1,4 +1,5 @@
 import { isNotNullish } from "@optolith/helpers/nullable";
+import { attributedName } from "../../markdown.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the translation of a rated sum prerequisite.
@@ -8,7 +9,7 @@ export const printRatedSumPrerequisite = (getInstanceById, locale, prerequisite)
         return printDisplayOption(locale.translateMap, prerequisite.display_option);
     }
     const skills = prerequisite.targets
-        .map(skillId => locale.translateMap(getInstanceById("Skill", skillId)?.translations)?.name)
+        .map(skillId => attributedName(locale.translateMap, getInstanceById, "prerequisite", "Skill", skillId))
         .filter(isNotNullish);
     return {
         value: locale.translate("the SR for {$skill} combined must add up to at least {$minRating}", {

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

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

package/lib/entities/partial/rated/activatable/checkResultBased.js

@@ -1,6 +1,6 @@
 import { mapNullableDefault } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { divisionFormatter, multiplicationFormatter, } from "../../mathOperation.js";
+import { divisionFormatter, multiplicationFormatter } from "../../mathOperation.js";
 import { translateR } from "../../reader.js";
 const renderCheckResultBaseValue = (baseValue) => {
     switch (baseValue.kind) {
@@ -8,6 +8,8 @@ const renderCheckResultBaseValue = (baseValue) => {
             return translateR("QL");
         case "SkillPoints":
             return translateR("SP");
+        case "SkillRating":
+            return translateR("SR");
         default:
             return assertExhaustive(baseValue);
     }

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

@@ -133,6 +133,39 @@ export declare const strictNameR: <E extends { [K in keyof EntityMap]: EntityMap
     translateMap: TranslateMap;
     getInstanceById: GetInstanceById<E>;
 }, string>;
+/**
+ * Retrieves the `name` property of the specified entry in an attributed string.
+ */
+export declare const attributedNameR: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} ? K : never; }[keyof EntityMap]>(context: string, ...args: IdArgsVariant<EntityMap, E>) => Reader<{
+    translateMap: TranslateMap;
+    getInstanceById: GetInstanceById<E>;
+}, string | undefined>;
+/**
+ * Applies a function to the translation of the specified entry and renders it in an attributed string.
+ */
+export declare const attributedCustomNameR: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} ? K : never; }[keyof EntityMap]>(context: string, fn: (translation: EntityMap[E]["translations"][string]) => string, ...args: IdArgsVariant<EntityMap, E>) => Reader<{
+    translateMap: TranslateMap;
+    getInstanceById: GetInstanceById<E>;
+}, string | undefined>;
+/**
+ * Applies a function to the translation of the specified entry.
+ */
+export declare const customNameR: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} ? K : never; }[keyof EntityMap]>(fn: (translation: EntityMap[E]["translations"][string]) => string, ...args: IdArgsVariant<EntityMap, E>) => Reader<{
+    translateMap: TranslateMap;
+    getInstanceById: GetInstanceById<E>;
+}, string | undefined>;
 /**
  * Joins a list of strings according to the locale’s rules for the given type.
  */

package/lib/entities/partial/reader.js

@@ -1,6 +1,7 @@
 import { isNotNullish } from "@elyukai/utils/nullable";
 import { Reader } from "@elyukai/utils/reader";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { attributedCustomName, attributedName, customName } from "./markdown.js";
 import { Speed } from "./rated/activatable/speed.js";
 import { responsive, ResponsiveTextSize } from "./responsiveText.js";
 import { formatEnergy } from "./units/energy.js";
@@ -50,6 +51,18 @@ export const nameR = (...args) => Reader.asks(env => env.translateMap(env.getIns
  * Returns {@link MISSING_VALUE} if there is no name for the entry in the locale. This can happen if the entry itself does not exist, or it does not have a translation for the current locale.
  */
 export const strictNameR = (...args) => nameR(...args).map(name => name ?? MISSING_VALUE);
+/**
+ * Retrieves the `name` property of the specified entry in an attributed string.
+ */
+export const attributedNameR = (context, ...args) => Reader.asks(env => attributedName(env.translateMap, env.getInstanceById, context, ...args));
+/**
+ * Applies a function to the translation of the specified entry and renders it in an attributed string.
+ */
+export const attributedCustomNameR = (context, fn, ...args) => Reader.asks(env => attributedCustomName(env.translateMap, env.getInstanceById, context, fn, ...args));
+/**
+ * Applies a function to the translation of the specified entry.
+ */
+export const customNameR = (fn, ...args) => Reader.asks(env => customName(env.translateMap, env.getInstanceById, fn, ...args));
 /**
  * Joins a list of strings according to the locale’s rules for the given type.
  */

package/lib/entities/personalityTrait.js

@@ -1,8 +1,10 @@
 import { on } from "@elyukai/utils/function";
+import { mapNullable } from "@elyukai/utils/nullable";
 import { compareNullish } from "@elyukai/utils/ordering";
 import { romanize } from "@elyukai/utils/roman";
 import { numAsc } from "@optolith/helpers/compare";
 import { createEntityDescriptionCreator } from "../creator.js";
+import { attributedNameFromInstance } from "./partial/markdown.js";
 import { printPersonalityTraitPrerequisites } from "./partial/prerequisites/index.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
 /**
@@ -31,13 +33,18 @@ export const getPersonalityTraitEntityDescription = createEntityDescriptionCreat
                         ? undefined
                         : {
                             label: translate("Can be combined with"),
-                            value: Map.groupBy(entry.combination_options.map(optionId => getInstanceById("PersonalityTrait", optionId)), option => option?.level ?? null)
+                            value: Map.groupBy(entry.combination_options.map(optionId => mapNullable(getInstanceById("PersonalityTrait", optionId), pt => ({
+                                id: optionId,
+                                content: pt,
+                            }))), option => option?.content.level ?? null)
                                 .entries()
                                 .toArray()
                                 .toSorted(on(group => group[0], compareNullish(numAsc)))
                                 .map(([level, options]) => level === null
                                 ? MISSING_VALUE
-                                : `${translate("Level {$level}", { level: romanize(level) })} ${localeJoin(options.map(option => translateMap(option?.translations)?.name ?? MISSING_VALUE), "disjunction")}`)
+                                : `${translate("Level {$level}", { level: romanize(level) })} ${localeJoin(options.map(option => (option &&
+                                    attributedNameFromInstance(translateMap, option.content, "prerequisite", "PersonalityTrait", option.id)) ??
+                                    MISSING_VALUE), "disjunction")}`)
                                 .join(", "),
                         },
                     entry.prerequisites === undefined

package/lib/entities/poison.js

@@ -3,7 +3,7 @@ import { isNotNullish, mapNullable } from "@elyukai/utils/nullable";
 import { sign } from "@elyukai/utils/string/number";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { createEntityDescriptionCreator } from "../creator.js";
-import { renderDice, renderDiceAndFlat } from "./partial/dice.js";
+import { renderDice } from "./partial/dice.js";
 import { renderAlternativeNames, renderChance, renderLaboratoryLevel, renderResistance, } from "./partial/herbary.js";
 import { renderMathOperation } from "./partial/mathOperation.js";
 import { printPlainGeneralPrerequisites } from "./partial/prerequisites/index.js";
@@ -93,6 +93,12 @@ const renderSourceTypeBasedValues = (translate, translateMap, getInstanceById, s
             return {
                 level: renderLevel(translate, translateMap, sourceType.AnimalVenom.level),
                 sourceType: translate("animal venom"),
+                tradeSecret: mapNullable(sourceType.AnimalVenom.complexity, complexity => complexity.kind === "Complex"
+                    ? {
+                        apValue: complexity.Complex.ap_value,
+                        prerequisites: complexity.Complex.prerequisites,
+                    }
+                    : undefined),
             };
         case "AlchemicalPoison": {
             const translation = translateMap(sourceType.AlchemicalPoison.translations);
@@ -156,10 +162,19 @@ const renderStart = (translate, translateMap, start) => {
     switch (start.kind) {
         case "Immediate":
             return translate("immediate");
-        case "Constant":
-            return formatTimeSpan(translate, ResponsiveTextSize.Full, start.Constant.unit, start.Constant.value);
-        case "DiceBased":
-            return formatTimeSpan(translate, ResponsiveTextSize.Full, start.DiceBased.unit, renderDiceAndFlat(translate, start.DiceBased.dice, start.DiceBased.flat));
+        case "ExpressionBased":
+            return renderMathOperation(start.ExpressionBased.value, value => {
+                switch (value.kind) {
+                    case "Constant":
+                        return value.Constant.toFixed();
+                    case "Dice":
+                        return renderDice(translate, value.Dice);
+                    case "CircleOfDamnation":
+                        return translate("CoD");
+                    default:
+                        return assertExhaustive(value);
+                }
+            });
         case "Indefinite":
             return translateMap(start.Indefinite.translations)?.description ?? MISSING_VALUE;
         default:
@@ -170,10 +185,6 @@ const renderDuration = (translate, translateMap, duration) => {
     switch (duration.kind) {
         case "Instant":
             return translate("instant");
-        case "Constant":
-            return formatTimeSpan(translate, ResponsiveTextSize.Full, duration.Constant.unit, duration.Constant.value);
-        case "DiceBased":
-            return formatTimeSpan(translate, ResponsiveTextSize.Full, duration.DiceBased.unit, renderDiceAndFlat(translate, duration.DiceBased.dice, duration.DiceBased.flat));
         case "ExpressionBased":
             return renderMathOperation(duration.ExpressionBased.value, value => {
                 switch (value.kind) {

package/lib/entities/profession.d.ts

@@ -1,11 +1,11 @@
-import type { MagicalActionIdentifier, RatedIdentifier, SpecialAbilityIdentifier } from "optolith-database-schema/gen";
+import type { MagicalActionIdentifier, ProfessionSpecialAbilityIdentifier, RatedIdentifier } from "optolith-database-schema/gen";
 import type { GetAllChildInstancesForParent, GetAllInstances, GetInstanceById } from "../helpers/getTypes.js";
 import { type GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";
 /**
  * Get a JSON representation of the rules text for a profession version.
  */
 export declare const getProfessionVersionEntityDescription: import("../creator.js").EntityDescriptionCreator<"ProfessionVersion", {
-    getInstanceById: GetInstanceById<"Publication" | "ExperienceLevel" | "Advantage" | "Disadvantage" | SpecialAbilityIdentifier["kind"] | "Aspect" | RatedIdentifier["kind"] | "Race" | "Culture" | MagicalActionIdentifier["kind"] | "SkillGroup" | "Cantrip" | "Blessing">;
+    getInstanceById: GetInstanceById<"Publication" | "ExperienceLevel" | "Advantage" | "Disadvantage" | ProfessionSpecialAbilityIdentifier["kind"] | "Aspect" | RatedIdentifier["kind"] | "Race" | "Culture" | MagicalActionIdentifier["kind"] | "SkillGroup" | "Cantrip" | "Blessing">;
     getAllInstances: GetAllInstances<"SkillGroup">;
     getChildInstancesForInstanceId: GetAllChildInstancesForParent<"ProfessionPackage" | "ProfessionVariant">;
     getResolvedSelectOptionById: GetResolvedSelectOptionById;