@optolith/entity-descriptions 0.11.2 → 0.13.0

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.13.0](https://github.com/Optolith/entity-descriptions/compare/v0.12.0...v0.13.0) (2026-09-16)
+
+### ⚠ BREAKING CHANGES
+
+* **deps:** upgrade to schema 0.63.0
+
+### build
+
+* **deps:** upgrade to schema 0.63.0 ([e879198](https://github.com/Optolith/entity-descriptions/commit/e8791981d739ad4ea786d566eeeb80c918f6e7d5))
+## [0.12.0](https://github.com/Optolith/entity-descriptions/compare/v0.11.2...v0.12.0) (2026-09-15)
+
+### ⚠ BREAKING CHANGES
+
+* **deps:** upgrade to schema 0.62.0
+
+### build
+
+* **deps:** upgrade to schema 0.62.0 ([13badb3](https://github.com/Optolith/entity-descriptions/commit/13badb304c61a1f4b48241435d5e19400bbbd145))
+
+### Bug Fixes
+
+* nested attributed strings in professions ([cdecedd](https://github.com/Optolith/entity-descriptions/commit/cdecedd5552bb22af4bfec73c4d06ca4b30e3121))
 ## [0.11.2](https://github.com/Optolith/entity-descriptions/compare/v0.11.1...v0.11.2) (2026-09-14)
 
 ### Bug Fixes

package/lib/entities/activatable.js

@@ -15,7 +15,7 @@ import { Case, fromUniformCase } from "tsondb/schema/gen";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderActivatableNameComponents } from "./partial/activatableNameChunks.js";
 import { renderAdventurePointsValue } from "./partial/adventurePointsValue.js";
-import { renderResponsiveMap } from "./partial/map.js";
+import { renderParameterMap } from "./partial/map.js";
 import { attributedName } from "./partial/markdown.js";
 import { additionFormatter } from "./partial/mathOperation.js";
 import { printAdvantageDisadvantagePrerequisites, printGeneralPrerequisites, } from "./partial/prerequisites/index.js";
@@ -311,7 +311,7 @@ const renderVolumeValue = (translate, translateMap, getAllResolvedSelectOptions,
                 levels: volume.ByLevel.list.map((_, index) => romanize(index + 1)).join("/"),
             });
         case "Map":
-            return renderResponsiveMap(volume.Map, option => Reader.of(option.points), values => translateR("{$points} points", { points: values })).run({
+            return renderParameterMap(volume.Map, option => Reader.of(option.points), values => translateR("{$points} points", { points: values })).run({
                 translate,
                 translateMap,
                 responsiveTextSize,
@@ -454,7 +454,7 @@ const renderBindingCost = (translate, translateMap, localeCompare, getAllResolve
                 }),
             });
         case "Map":
-            return renderResponsiveMap(cost.Map, option => Reader.of(option.permanentValue), values => translateR("{$value} permanent AE", { value: values })).run({
+            return renderParameterMap(cost.Map, option => Reader.of(option.permanentValue), values => translateR("{$value} permanent AE", { value: values })).run({
                 translate,
                 translateMap,
                 responsiveTextSize,

package/lib/entities/partial/activatableNameChunks.js

@@ -136,7 +136,7 @@ export const renderCombinedActivatableNameComponents = (translateMap, components
         useParenthesis: true,
     },
     options: join(components.options.map(chunk => renderActivatableNameChunk(translateMap, normalizeChunks(chunk)))),
-}, formatAsPrerequisite), components.id.kind, fromUniformCase(components.id), { context });
+}, formatAsPrerequisite), components.id.kind, fromUniformCase(components.id), { context: `"${context}"` });
 /**
  * Renders the name components of multiple activatable entries.
  */

package/lib/entities/partial/adventurePointsValue.js

@@ -1,10 +1,14 @@
 import { on } from "@elyukai/utils/function";
 import { isNotNullish } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
 import { unique } from "@optolith/helpers/array";
 import { deepEqual, numAsc } from "@optolith/helpers/compare";
 import { romanize } from "@optolith/helpers/roman";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { renderDefaultValueMapLabel, renderValueMap } from "./map.js";
 import { evaluateMathOperation } from "./mathOperation.js";
+import { translateR } from "./reader.js";
+import { ResponsiveTextSize } from "./responsiveText.js";
 import { MISSING_VALUE } from "./unknown.js";
 const typographicSign = (num) => (num > 0 ? "" : "−") + Math.abs(num).toFixed();
 const renderFixedSelectOptionsAdventurePointsValue = (locale, getAllSelectOptions, getNameForSelectOptionId, getApValueForSelectOption, applyNegative) => {
@@ -250,8 +254,10 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
                         });
                     }
                 case "Expression": {
-                    const expression = value.DependingOnActiveInstances.Expression;
-                    const values = Array.from({ length: entry.maximum ?? 3 }, (_, index) => applyNegative(evaluateMathOperation(expression, exprValue => {
+                    const { expression, customLabels } = value.DependingOnActiveInstances.Expression;
+                    const values = Array.from({
+                        length: entry.maximum ?? (customLabels === undefined ? 3 : customLabels.options.length),
+                    }, (_, index) => applyNegative(evaluateMathOperation(expression, exprValue => {
                         switch (exprValue.kind) {
                             case "Constant":
                                 return exprValue.Constant;
@@ -260,7 +266,18 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
                             default:
                                 return assertExhaustive(exprValue);
                         }
-                    }))).join("/");
+                    })));
+                    if (customLabels !== undefined) {
+                        return renderValueMap(entry.maximum === undefined
+                            ? customLabels
+                            : { ...customLabels, options: customLabels.options.slice(0, entry.maximum) }, 
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- customLabels.options is guaranteed to have at least as many entries as values
+                        (_, index) => Reader.of(values[index]), renderDefaultValueMapLabel, singleValue => typeof singleValue === "number"
+                            ? translateR(".input {$value :number} {{{$value} Adventure Points}}", {
+                                value: singleValue,
+                            })
+                            : translateR("{$value} Adventure Points", { value: singleValue })).run({ translate, translateMap, responsiveTextSize: ResponsiveTextSize.Full });
+                    }
                     const labels = Array.from({ length: entry.maximum ?? 3 }, (_, index) => `${(index + 1).toFixed()}.`).join("/");
                     if (entry.maximum !== undefined) {
                         return translate("{$values} Adventure Points for the {$labels} purchase", {

package/lib/entities/partial/commonnessRatedAdvantagesAndDisadvantages.js

@@ -5,7 +5,7 @@ import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { ensureNonEmpty } from "@optolith/helpers/array";
 import { Case } from "tsondb/schema/gen";
 import { makeNameBuilderRulesWithDefaults, renderCombinedActivatableNameComponents, renderNameComponentsOptions, } from "./activatableNameChunks.js";
-import { attributedCustomName } from "./markdown.js";
+import { attributedNameFromText, customName } from "./markdown.js";
 import { MISSING_VALUE } from "./unknown.js";
 const convertCommonnessRatedAdvantageOrDisadvantageLevel = (level) => {
     switch (level.kind) {
@@ -29,9 +29,9 @@ const makeActivatableIdentifierForCommonnessRatedAdvantageOrDisadvantage = (enti
 };
 const renderCommonnessRatedAdvantageOrDisadvantageName = (translateMap, getInstanceById, getResolvedSelectOptionById, localeCompare, entity, item) => {
     const customTranslation = translateMap(item.translations);
-    return (attributedCustomName(translateMap, getInstanceById, entity, (translation, instance) => {
+    return (customName(translateMap, getInstanceById, (translation, instance) => {
         if (customTranslation?.full !== undefined) {
-            return customTranslation.full;
+            return attributedNameFromText(customTranslation.full, "commonness", entity, item.id);
         }
         const id = makeActivatableIdentifierForCommonnessRatedAdvantageOrDisadvantage(entity, item.id);
         const level = item.level === undefined

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

@@ -1,40 +1,26 @@
 import { Reader } from "@elyukai/utils/reader";
-import type { ParameterMapStyle, ResponsiveTextOptional } from "@optolith/database-schema/gen";
+import type { ParameterMap, ParameterMapOption, ResponsiveTextOptional, ValueMap } from "@optolith/database-schema/gen";
 import type { StdEnv, StdReader } from "../../env.js";
 import type { LocaleMap } from "../../helpers/translate.js";
 /**
  * Renders a map of options to a string.
  */
-export declare const renderMap: <V, T, OT, VEnv, SVEnv>(map: {
-    options: {
-        value: V;
-        translations?: LocaleMap<OT>;
-    }[];
-    style: ParameterMapStyle;
-    translations?: LocaleMap<T>;
-}, getValue: (option: V) => Reader<VEnv, string | number>, surroundValues: ((values: string) => Reader<SVEnv, string>) | undefined, getLabel: (optionTranslation: OT) => string, getListPrefix: (translation: T) => string | undefined, getListSuffix: (translation: T) => string | undefined, getReplacement: (translation: T) => string | undefined, ...moreToAppend: ({
-    surround: (values: string) => StdReader<string, "t">;
-    getAdditionalValue: (option: V, optionTranslation: OT) => string | number;
-} | undefined)[]) => Reader<StdEnv<"t" | "tm"> & VEnv & SVEnv, string>;
+export declare const renderValueMap: <T, TE1, TE2, TE3, TE4, TE5, V extends string | number>(map: ValueMap<T>, renderValueMapOptionValue: (option: T, index: number) => Reader<TE1, V>, renderValueMapOptionLabel: (option: T, index: number) => Reader<TE2, string>, formatValue: (value: V | string) => Reader<TE3, string>, ...moreToAppend: ({
+    render: (option: T, index: number) => Reader<TE4, V>;
+    format: (value: V | string) => Reader<TE5, string>;
+} | undefined)[]) => Reader<TE1 & TE2 & TE3 & TE4 & TE5 & StdEnv<"t" | "tm" | "rts">, string>;
 /**
- * Renders a map of options to a string.
+ * Render the label of a value map option.
  */
-export declare const renderResponsiveMap: <T, VEnv, SVEnv>(map: {
-    options: {
-        value: T;
-        translations?: LocaleMap<{
-            label: ResponsiveTextOptional;
-        }>;
-    }[];
-    style: ParameterMapStyle;
-    translations?: LocaleMap<{
-        listPrefix?: ResponsiveTextOptional;
-        listSuffix?: ResponsiveTextOptional;
-        replacement?: ResponsiveTextOptional;
-    }>;
-}, getValue: (option: T) => Reader<VEnv, string | number>, surroundValues: ((values: string) => Reader<SVEnv, string>) | undefined, ...moreToAppend: ({
-    surround: (values: string) => StdReader<string, "t">;
-    getAdditionalValue: (option: T, optionTranslation: {
+export declare const renderDefaultValueMapLabel: (option: {
+    translations: LocaleMap<{
         label: ResponsiveTextOptional;
-    }) => string | number;
-} | undefined)[]) => Reader<StdEnv<"t" | "tm" | "rts"> & VEnv & SVEnv, string>;
+    }>;
+}) => StdReader<string, "tm" | "rts">;
+/**
+ * Renders a map of parameter options to a string.
+ */
+export declare const renderParameterMap: <T, TE1, TE2, TE3, TE4, V extends string | number>(map: ParameterMap<T>, renderParameterMapValue: (value: T, index: number) => Reader<TE1, V>, formatValue: (value: V | string) => Reader<TE2, string>, ...moreToAppend: ({
+    render: (option: ParameterMapOption<T>, index: number) => Reader<TE3, V>;
+    format: (value: V | string) => Reader<TE4, string>;
+} | undefined)[]) => Reader<TE1 & StdEnv<"tm" | "rts"> & TE2 & TE3 & TE4 & StdEnv<"t" | "tm" | "rts">, string>;

package/lib/entities/partial/map.js

@@ -1,57 +1,44 @@
-import { mapNullableDefault } from "@elyukai/utils/nullable";
 import { Reader } from "@elyukai/utils/reader";
-import { isNotNullish, mapNullable } from "@optolith/helpers/nullable";
-import { getResponsiveTextOptional } from "./responsiveText.js";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { isNotNullish } from "@optolith/helpers/nullable";
+import { responsiveTextOptionalR, sequence, translateMapR, translateR } from "./reader.js";
 import { MISSING_VALUE } from "./unknown.js";
+const renderReplacement = (translation, alt) => translation?.replacement !== undefined
+    ? responsiveTextOptionalR(translation.replacement).thenW(replacement => replacement === undefined ? alt() : Reader.of(replacement))
+    : alt();
+const renderListJoiner = (joiner, spacePosition) => joiner === undefined
+    ? ""
+    : responsiveTextOptionalR(joiner).map(text => text === undefined ? "" : spacePosition === "before" ? ` ${text}` : `${text} `);
 /**
  * Renders a map of options to a string.
  */
-export const renderMap = (map, getValue, surroundValues = values => Reader.of(values), getLabel, getListPrefix, getListSuffix, getReplacement, ...moreToAppend) => Reader.asks(env => {
-    const translation = env.translateMap(map.translations);
-    const replacement = mapNullable(translation, t => getReplacement(t));
-    if (isNotNullish(replacement)) {
-        return replacement;
-    }
-    if (map.style.kind === "Verbose") {
-        return map.options
-            .map(option => {
-            const value = getValue(option.value).run(env);
-            const optionTranslation = env.translateMap(option.translations);
-            return `${surroundValues(typeof value === "number" ? value.toFixed() : value).run(env)} ${env.translate("for")} ${mapNullableDefault(mapNullable(translation, getListPrefix), listPrefix => `${listPrefix} `, "")}${optionTranslation === undefined ? MISSING_VALUE : getLabel(optionTranslation)}${mapNullableDefault(mapNullable(translation, getListSuffix), listSuffix => ` ${listSuffix}`, "")}${moreToAppend
-                .filter(isNotNullish)
-                .map(({ surround, getAdditionalValue }) => {
-                const additionalValue = optionTranslation === undefined
-                    ? MISSING_VALUE
-                    : getAdditionalValue(option.value, optionTranslation);
-                return surround(typeof additionalValue === "number" ? additionalValue.toFixed() : additionalValue).run(env);
-            })
-                .join("")}`;
-        })
-            .join(", ");
-    }
-    return `${surroundValues(map.options.map(option => getValue(option.value).run(env)).join("/")).run(env)} ${env.translate("for")} ${mapNullableDefault(mapNullable(translation, getListPrefix), listPrefix => `${listPrefix} `, "")}${map.options
-        .map(option => {
-        const optionTranslation = env.translateMap(option.translations);
-        if (optionTranslation === undefined) {
-            return MISSING_VALUE;
+export const renderValueMap = (map, renderValueMapOptionValue, renderValueMapOptionLabel, formatValue, ...moreToAppend) => translateMapR(map.translations).thenW(translation => renderReplacement(translation, () => {
+    const { listPrefix, listSuffix } = translation ?? {};
+    const listPrefixR = renderListJoiner(listPrefix, "after");
+    const listSuffixR = renderListJoiner(listSuffix, "before");
+    const moreToAppendFns = moreToAppend.filter(isNotNullish);
+    switch (map.style.kind) {
+        case "Compressed": {
+            return Reader.traverse(map.options, (option, index) => renderValueMapOptionValue(option, index).thenW(value => renderValueMapOptionLabel(option, index).map(label => ({ value, label })))).thenW(renderedOptions => sequence `${formatValue(renderedOptions.map(option => (typeof option.value === "number" ? option.value.toFixed() : option.value)).join("/"))} ${translateR("for")} ${listPrefixR}${renderedOptions
+                .map(option => option.label)
+                .join("/")}${listSuffixR}${Reader.traverse(moreToAppendFns, more => Reader.traverse(map.options, more.render).thenW(values => more.format(values.join("/")))).map(values => values.join(""))}`);
         }
-        return getLabel(optionTranslation);
-    })
-        .join("/")}${mapNullableDefault(mapNullable(translation, getListSuffix), listSuffix => ` ${listSuffix}`, "")}${moreToAppend
-        .filter(isNotNullish)
-        .map(({ surround, getAdditionalValue }) => surround(map.options
-        .map(option => {
-        const optionTranslation = env.translateMap(option.translations);
-        if (optionTranslation === undefined) {
-            return MISSING_VALUE;
+        case "Verbose": {
+            return Reader.traverse(map.options, (option, index) => renderValueMapOptionValue(option, index)
+                .thenW(value => renderValueMapOptionLabel(option, index).map(label => ({ value, label })))
+                .thenW(({ value, label }) => sequence `${formatValue(value)} ${translateR("for")} ${listPrefixR}${label}${listSuffixR}${Reader.traverse(moreToAppendFns, more => more.render(option, index).thenW(more.format)).map(values => values.join(""))}`)).map(values => values.join(", "));
         }
-        return getAdditionalValue(option.value, optionTranslation);
-    })
-        .join("/")).run(env))
-        .join("")}`;
-});
+        default:
+            return assertExhaustive(map.style);
+    }
+}));
 /**
- * Renders a map of options to a string.
+ * Render the label of a value map option.
+ */
+export const renderDefaultValueMapLabel = (option) => translateMapR(option.translations).thenW(translation => translation?.label === undefined
+    ? Reader.of(MISSING_VALUE)
+    : responsiveTextOptionalR(translation.label).map(text => text ?? translation.label.full));
+/**
+ * Renders a map of parameter options to a string.
  */
-export const renderResponsiveMap = (map, getValue, surroundValues, ...moreToAppend) => Reader.asks(env => renderMap(map, getValue, surroundValues, translation => getResponsiveTextOptional(translation.label, env.responsiveTextSize) ??
-    translation.label.full, translation => mapNullable(translation.listPrefix, text => getResponsiveTextOptional(text, env.responsiveTextSize)), translation => mapNullable(translation.listSuffix, text => getResponsiveTextOptional(text, env.responsiveTextSize)), translation => mapNullable(translation.replacement, text => getResponsiveTextOptional(text, env.responsiveTextSize)), ...moreToAppend).run(env));
+export const renderParameterMap = (map, renderParameterMapValue, formatValue, ...moreToAppend) => renderValueMap(map, (option, index) => renderParameterMapValue(option.value, index), renderDefaultValueMapLabel, formatValue, ...moreToAppend);

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

@@ -26,7 +26,7 @@ export declare const attributedName: <E extends { [K in keyof EntityMap]: Entity
  */
 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;
+} ? K : never; }[keyof EntityMap]>(translateMap: TranslateMap, getInstanceById: GetInstanceById<E>, fn: (translation: EntityMap[E]["translations"][string], instance: EntityMap[E]) => string, ...args: IdArgsVariant<EntityMap, E>) => string | undefined;
 /**
  * Renders the name of an instance according to a custom function in an attributed string.
  */
@@ -47,6 +47,10 @@ export declare const attributedNameFromInstance: (translateMap: TranslateMap, in
 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 attributedNameFromText: (text: string, context: string, ...args: IdArgsVariant<EntityMap, keyof EntityMap>) => string;
 /**
  * Renders the name of an instance in an attributed string.
  */

package/lib/entities/partial/markdown.js

@@ -28,7 +28,12 @@ export const attributedName = (translateMap, getInstanceById, context, ...args)
 /**
  * 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));
+export const customName = (translateMap, getInstanceById, fn, ...args) => {
+    const instance = getInstanceById(...args);
+    return mapNullable(translateMap(instance?.translations), translation => 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- instance must be non-nullish if translation is non-nullish
+    fn(translation, instance));
+};
 /**
  * Renders the name of an instance according to a custom function in an attributed string.
  */
@@ -53,6 +58,13 @@ 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 attributedNameFromText = (text, context, ...args) => {
+    const id = normalizedIdArgs(args);
+    return attributedInstance(text, id.entityName, id.id, { context: `"${context}"` });
+};
 /**
  * Renders the name of an instance in an attributed string.
  */

package/lib/entities/partial/prerequisites/index.d.ts

@@ -1,5 +1,5 @@
 import { Reader } from "@elyukai/utils/reader";
-import type { ActivatableIdentifier, AdvantageDisadvantagePrerequisites, AnimistPowerPrerequisites, ArcaneTraditionPrerequisites, DerivedCharacteristicPrerequisites, EnhancementPrerequisites, GeneralPrerequisites, GeodeRitualPrerequisites, InfluencePrerequisites, LanguagePrerequisites, LiturgyPrerequisites, PersonalityTraitPrerequisites, PlainGeneralPrerequisites, ProfessionPrerequisites, PublicationPrerequisites, SpellworkPrerequisites } from "@optolith/database-schema/gen";
+import type { ActivatableIdentifier, AdvantageDisadvantagePrerequisites, AnimistPowerPrerequisites, ArcaneTraditionPrerequisites, DerivedCharacteristicPrerequisites, EnhancementPrerequisites, GeneralPrerequisites, GeodeRitualPrerequisites, InfluencePrerequisites, LanguagePrerequisites, LiturgyPrerequisites, PersonalityTraitPrerequisites, PlainGeneralPrerequisites, ProfessionPrerequisites, ProfessionVariantPrerequisites, PublicationPrerequisites, SpellworkPrerequisites } from "@optolith/database-schema/gen";
 import type { StdEnv } from "../../../env.js";
 import { printAdvantageDisadvantagePrerequisiteGroup, printAnimistPowerPrerequisiteGroup, printArcaneTraditionPrerequisiteGroup, printDerivedCharacteristicPrerequisiteGroup, printEnhancementPrerequisiteGroup, printGeneralPrerequisiteGroup, printGeodeRitualPrerequisiteGroup, printInfluencePrerequisiteGroup, printLanguagePrerequisiteGroup, printLiturgyPrerequisiteGroup, printPersonalityTraitPrerequisiteGroup, printProfessionPrerequisiteGroup, printPublicationPrerequisiteGroup, printSpellworkPrerequisiteGroup } from "./prerequisiteGroups.js";
 type DeriveEnvF<T extends (...args: any[]) => any> = ReturnType<T> extends Reader<infer E, unknown> ? E : never;
@@ -26,6 +26,10 @@ export declare const printGeneralPrerequisites: (value: GeneralPrerequisites, pr
  * Print profession prerequisites as a string.
  */
 export declare const printProfessionPrerequisites: (value: ProfessionPrerequisites) => Reader<DeriveEnvF<typeof printProfessionPrerequisiteGroup> & StdEnv<"lj" | "lc">, string>;
+/**
+ * Print profession prerequisites as a string.
+ */
+export declare const printProfessionVariantPrerequisites: (value: ProfessionVariantPrerequisites) => Reader<DeriveEnvF<typeof printProfessionPrerequisiteGroup> & StdEnv<"lj" | "lc">, string>;
 /**
  * Print advantage disadvantage prerequisites as a string.
  */

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

@@ -76,6 +76,23 @@ const printPlainPrerequisites = (printPrerequisite, prerequisites) => Reader.tra
     type: element.kind === "Single" ? element.Single.kind : element.kind,
     part,
 })))).thenW(list => joinPrerequisiteParts(list.filter(isNotNullish)));
+const printPrerequisiteDiff = (printPrerequisite, map, element) => {
+    switch (element.kind) {
+        case "Add":
+            return printPrerequisite(element.Add).map(part => map(element.Add, part));
+        case "Remove":
+            return printPrerequisite(element.Remove).map(part => map(element.Remove, part === undefined ? undefined : { ...part, isRemoved: true }));
+        default:
+            return assertExhaustive(element);
+    }
+};
+/**
+ * Print plain prerequisites as a string.
+ */
+const printPlainDiffPrerequisites = (printPrerequisite, prerequisites) => Reader.traverse(prerequisites, diffElement => printPrerequisiteDiff(element => printPrerequisitesElement(printPrerequisite, element), (element, nullablePart) => mapNullable(nullablePart, part => ({
+    type: element.kind === "Single" ? element.Single.kind : element.kind,
+    part,
+})), diffElement)).thenW(list => joinPrerequisiteParts(list.filter(isNotNullish)));
 /**
  * Print prerequisite for level as a string.
  */
@@ -169,6 +186,10 @@ export const printGeneralPrerequisites = (value, printPreviousLevelPrerequisites
  * Print profession prerequisites as a string.
  */
 export const printProfessionPrerequisites = (value) => printPlainPrerequisites(printProfessionPrerequisiteGroup, value);
+/**
+ * Print profession prerequisites as a string.
+ */
+export const printProfessionVariantPrerequisites = (value) => printPlainDiffPrerequisites(printProfessionPrerequisiteGroup, value);
 /**
  * Print advantage disadvantage prerequisites as a string.
  */

package/lib/entities/partial/prerequisites/part.d.ts

@@ -9,6 +9,7 @@ export type PrerequisitePart = {
     value: string | ActivatableNameComponents;
     sentenceType: SentenceType | undefined;
     isMeta: boolean;
+    isRemoved?: true;
 };
 /**
  * Type guard for prerequisite parts with a value object.

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

@@ -15,7 +15,8 @@ export const hasPartValueObject = (part) => typeof part.value !== "string";
 const countFurtherToCombined = (part, remainingParts) => {
     const indexHasDifferentBaseValues = remainingParts.findIndex(remaining => !(part.label === remaining.label &&
         deepEqual(part.value.id, remaining.value.id) &&
-        part.value.level === remaining.value.level));
+        part.value.level === remaining.value.level &&
+        part.isRemoved === remaining.isRemoved));
     return indexHasDifferentBaseValues === -1
         ? // if -1 is returned, all remaining parts have the same base values, so we can combine with all of them
             remainingParts.length
@@ -59,8 +60,11 @@ const appendPrerequisitePartGroup = (previous, parts, isLast) => {
     if (parts.length === 0) {
         return Reader.of(previous);
     }
-    else if (parts.every(hasPartValueObject)) {
-        return Reader.asks(({ translate, translateMap, localeCompare }) => appendBySentenceType(previous, parts
+    const wrapInNoPrerequisite = (text) => parts[0]?.isRemoved === true
+        ? translateR("no prerequisite {$prerequisite}", { prerequisite: text })
+        : Reader.of(text);
+    if (parts.every(hasPartValueObject)) {
+        return Reader.asks(({ translate, translateMap, localeCompare }) => appendBySentenceType(previous, wrapInNoPrerequisite(parts
             .toSorted(on(part => fromUniformCase(part.value.id), localeCompare))
             .reduce((acc, current, i, arr) => {
             if (acc[1] > 0) {
@@ -70,20 +74,23 @@ const appendPrerequisitePartGroup = (previous, parts, isLast) => {
             return [
                 [
                     ...acc[0],
-                    [activatableKindToGroup(current.value.id.kind), (current.label ?? "") + rendered],
+                    [
+                        activatableKindToGroup(current.value.id.kind),
+                        (current.label ?? "") + rendered,
+                    ],
                 ],
                 furtherIncluded,
             ];
         }, [[], 0])[0]
             .toSorted(sortByActivatableGroupAndName(localeCompare))
             .map(grouped => grouped[1])
-            .join(", "), undefined, isLast));
+            .join(", ")).run({ translate }), undefined, isLast));
     }
     else {
-        return Reader.asks(({ translateMap }) => parts.reduce((acc, current, i, arr) => appendBySentenceType(acc, (current.label ?? "") +
+        return Reader.asks(({ translate, translateMap }) => parts.reduce((acc, current, i, arr) => appendBySentenceType(acc, wrapInNoPrerequisite((current.label ?? "") +
             (typeof current.value === "string"
                 ? current.value
-                : wrapActivatableInAttributedString(renderActivatableNameComponents(translateMap, current.value, true), current.value.id)), current.sentenceType, isLast && i === arr.length - 1), previous));
+                : wrapActivatableInAttributedString(renderActivatableNameComponents(translateMap, current.value, true), current.value.id))).run({ translate }), current.sentenceType, isLast && i === arr.length - 1), previous));
     }
 };
 /**

package/lib/entities/partial/rated/activatable/cost.d.ts

@@ -42,10 +42,12 @@ export declare const renderIndefiniteCost: (value: IndefiniteCost, shouldAppendN
 /**
  * Returns the text for a standalone one-time cost map of an activatable skill.
  */
-export declare const renderStandaloneCostMap: (value: StandaloneCostMap) => Reader<StdEnv<"t" | "tm" | "rts"> & {
+export declare const renderStandaloneCostMap: (value: StandaloneCostMap) => Reader<StdEnv<"tm" | "rts"> & {
     translate: import("../../../../helpers/translate.js").Translate;
     energyUnit: import("../../units/energy.js").EnergyUnit;
-}, string>;
+} & {
+    translate: import("../../../../helpers/translate.js").Translate;
+} & StdEnv<"t" | "tm" | "rts">, string>;
 /**
  * Returns the text for the cost of a one-time activatable skill.
  */

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

@@ -2,7 +2,7 @@ import { identity } from "@elyukai/utils/function";
 import { Reader } from "@elyukai/utils/reader";
 import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { renderResponsiveMap } from "../../map.js";
+import { renderParameterMap } from "../../map.js";
 import { formatEnergyFnR, formatEnergyR, getInstanceByIdFnR, modifiableBySpeedR, responsiveLocaleJoinR, responsiveR, responsiveTextR, responsiveTranslateR, translateMapR, translateR, } from "../../reader.js";
 import { appendNoteIfNeeded, replaceTextIfNeeded } from "../../responsiveText.js";
 import { formatCombinedTimeSpanR } from "../../units/timeSpan.js";
@@ -114,13 +114,13 @@ const renderMultipleOneTimeCosts = (type, value) => {
 /**
  * Returns the text for a standalone one-time cost map of an activatable skill.
  */
-export const renderStandaloneCostMap = (value) => renderResponsiveMap(value, option => Reader.of(option.value), formatEnergyR, value.options.every(option => option.value.permanentValue !== undefined)
+export const renderStandaloneCostMap = (value) => renderParameterMap(value, option => Reader.of(option.value), formatEnergyR, value.options.every(option => option.value.permanentValue !== undefined)
     ? {
-        surround: values => translateR(", {$value} of which are permanent", {
+        format: values => translateR(", {$value} of which are permanent", {
             value: values,
         }),
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
-        getAdditionalValue: option => option.permanentValue,
+        render: option => Reader.of(option.value.permanentValue),
     }
     : undefined);
 /**
@@ -129,23 +129,23 @@ export const renderStandaloneCostMap = (value) => renderResponsiveMap(value, opt
 const renderOneTimeCostMap = (value) => {
     switch (value.kind) {
         case "Modifiable":
-            return renderResponsiveMap(value.Modifiable.map, option => deriveModifiableCost(option.initialModificationLevel).map(cost => cost ?? MISSING_VALUE), formatEnergyR, value.Modifiable.map.options.every(option => option.value.permanentValue !== undefined)
+            return renderParameterMap(value.Modifiable.map, option => deriveModifiableCost(option.initialModificationLevel).map(cost => cost ?? MISSING_VALUE), singleValue => formatEnergyR(singleValue), value.Modifiable.map.options.every(option => option.value.permanentValue !== undefined)
                 ? {
-                    surround: values => translateR(", {$value} of which are permanent", {
+                    format: values => translateR(", {$value} of which are permanent", {
                         value: values,
                     }),
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
-                    getAdditionalValue: option => option.permanentValue,
+                    render: option => Reader.of(option.value.permanentValue),
                 }
                 : undefined);
         case "NonModifiable":
-            return renderResponsiveMap(value.NonModifiable.map, option => Reader.of(option.value), formatEnergyR, value.NonModifiable.map.options.every(option => option.value.permanentValue !== undefined)
+            return renderParameterMap(value.NonModifiable.map, option => Reader.of(option.value), formatEnergyR, value.NonModifiable.map.options.every(option => option.value.permanentValue !== undefined)
                 ? {
-                    surround: values => translateR(", {$value} of which are permanent", {
+                    format: values => translateR(", {$value} of which are permanent", {
                         value: values,
                     }),
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
-                    getAdditionalValue: option => option.permanentValue,
+                    render: option => Reader.of(option.value.permanentValue),
                 }
                 : undefined).then(text => appendNonModifiableSuffix(ModifiableParameter.Cost, text));
         default:
@@ -155,9 +155,9 @@ const renderOneTimeCostMap = (value) => {
 const renderSustainedCostMap = (value) => {
     switch (value.kind) {
         case "Modifiable":
-            return renderResponsiveMap(value.Modifiable.map, option => deriveModifiableCost(option.initialModificationLevel).map(cost => cost ?? MISSING_VALUE), singleValue => formatEnergyR(singleValue).thenW(energy => appendIntervalToCostR(value.Modifiable.interval, energy)));
+            return renderParameterMap(value.Modifiable.map, option => deriveModifiableCost(option.initialModificationLevel).map(cost => cost ?? MISSING_VALUE), singleValue => formatEnergyR(singleValue).thenW(energy => appendIntervalToCostR(value.Modifiable.interval, energy)));
         case "NonModifiable":
-            return renderResponsiveMap(value.NonModifiable.map, option => Reader.of(option.value), singleValue => formatEnergyR(singleValue).thenW(energy => appendIntervalToCostR(value.NonModifiable.interval, energy))).then(text => appendNonModifiableSuffix(ModifiableParameter.Cost, text));
+            return renderParameterMap(value.NonModifiable.map, option => Reader.of(option.value.toFixed()), singleValue => formatEnergyR(singleValue).thenW(energy => appendIntervalToCostR(value.NonModifiable.interval, energy))).then(text => appendNonModifiableSuffix(ModifiableParameter.Cost, text));
         default:
             return assertExhaustive(value);
     }

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

@@ -262,4 +262,8 @@ export declare const modifyBySpeedR: Reader<{
  * Returns the default values wrapped in a reader if the value is nullish, otherwise applies the given function to the value and returns the result.
  */
 export declare const mapNullableR: <T, U, R>(defaultValue: U, fn: (value: NonNullable<T>) => Reader<U, R>) => (value: T) => Reader<U, R> | Reader<unknown, U>;
+/**
+ * Use `Reader` instances directly in a template string.
+ */
+export declare const sequence: <E>(string: TemplateStringsArray, ...values: (Reader<E, string> | string)[]) => Reader<E, string>;
 export {};

package/lib/entities/partial/reader.js

@@ -194,3 +194,7 @@ export const modifyBySpeedR = Reader.asks(({ speed }) => (key, level) => {
  * Returns the default values wrapped in a reader if the value is nullish, otherwise applies the given function to the value and returns the result.
  */
 export const mapNullableR = (defaultValue, fn) => (value) => isNotNullish(value) ? fn(value) : Reader.of(defaultValue);
+/**
+ * Use `Reader` instances directly in a template string.
+ */
+export const sequence = (string, ...values) => Reader.traverse(values, value => (value instanceof Reader ? value : Reader.of(value))).map(resolvedValues => string.reduce((acc, str, i) => acc + str + (resolvedValues[i] ?? ""), ""));