@optolith/entity-descriptions 0.13.2 → 0.14.0

package/lib/entities/partial/profession/variants.js

@@ -0,0 +1,31 @@
+import { nullableToArray } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { fixedNumberOrString, translateR } from "../reader.js";
+import { MISSING_VALUE } from "../unknown.js";
+/**
+ * Renders an option for a profession variant, using the base profession package and the variant's options.
+ */
+export const renderVariantOption = (base, variant, key, render) => (variant.options?.[key] === undefined
+    ? Reader.of(undefined)
+    : render(base.options?.[key], variant.options[key])).map(text => nullableToArray(text));
+/**
+ * Render a variant option based on whether it is a removal, addition, or override of the base option.
+ */
+export const renderVariantOptionPaths = (base, variant, paths) => {
+    switch (variant.kind) {
+        case "Remove":
+            return base === undefined ? Reader.of(MISSING_VALUE) : paths.remove(base);
+        case "Override":
+            return base === undefined ? paths.add(variant.Override) : paths.update(base, variant.Override);
+        default:
+            return assertExhaustive(variant);
+    }
+};
+/**
+ * Helper for "X instead of Y" text.
+ */
+export const insteadOfR = (replacement, base) => translateR("{$replacement} instead of {$base}", {
+    replacement: fixedNumberOrString(replacement),
+    base: fixedNumberOrString(base),
+});

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

@@ -3,7 +3,7 @@ import { Reader } from "@elyukai/utils/reader";
 import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { renderParameterMap } from "../../map.js";
-import { formatEnergyFnR, formatEnergyR, getInstanceByIdFnR, modifiableBySpeedR, responsiveLocaleJoinR, responsiveR, responsiveTextR, responsiveTranslateR, translateMapR, translateR, } from "../../reader.js";
+import { fixedNumberOrString, formatEnergyFnR, formatEnergyR, getInstanceByIdFnR, modifiableBySpeedR, responsiveLocaleJoinR, responsiveR, responsiveTextR, responsiveTranslateR, responsiveTranslateSplitR, translateMapR, translateR, } from "../../reader.js";
 import { appendNoteIfNeeded, replaceTextIfNeeded } from "../../responsiveText.js";
 import { formatCombinedTimeSpanR } from "../../units/timeSpan.js";
 import { MISSING_VALUE } from "../../unknown.js";
@@ -33,9 +33,11 @@ const appendPerCountableToCostIfNeeded = (value, baseCost) => {
             })));
     });
 };
-const appendPermanentCostIfNeeded = (permanentValue, baseCost) => mapNullable(permanentValue, value => responsiveTranslateR(".input {$value :number} {{, {$value} of which are permanent}}", " ({$value} perm.)", { value }).map(text => baseCost + text)) ?? Reader.of(baseCost);
-const appendElvenPermanentCostIfNeeded = (permanent, baseCost) => mapNullable(permanent, value => responsiveTranslateR(".input {$value :number} {{{$value} permanent AE}}", "{$value} pAE", {
+const appendPermanentCostIfNeeded = (permanentValue, baseCost) => mapNullable(permanentValue, value => responsiveTranslateSplitR(".input {$value :number} {{, {$value} of which are permanent}}", " ({$value} perm.)", { value }, { value: value.toFixed() }).map(text => baseCost + text)) ?? Reader.of(baseCost);
+const appendElvenPermanentCostIfNeeded = (permanent, baseCost) => mapNullable(permanent, value => responsiveTranslateSplitR(".input {$value :number} {{{$value} permanent AE}}", "{$value} pAE", {
     value: value.value,
+}, {
+    value: value.value.toFixed(),
 })
     .thenW(text => replaceTextIfNeeded(value.translations, text))
     .map(text => baseCost + text)) ?? Reader.of(baseCost);
@@ -117,7 +119,7 @@ const renderMultipleOneTimeCosts = (type, value) => {
 export const renderStandaloneCostMap = (value) => renderParameterMap(value, option => Reader.of(option.value), formatEnergyR, value.options.every(option => option.value.permanentValue !== undefined)
     ? {
         format: values => translateR(", {$value} of which are permanent", {
-            value: values,
+            value: fixedNumberOrString(values),
         }),
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
         render: option => Reader.of(option.value.permanentValue),
@@ -132,7 +134,7 @@ const renderOneTimeCostMap = (value) => {
             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)
                 ? {
                     format: values => translateR(", {$value} of which are permanent", {
-                        value: values,
+                        value: fixedNumberOrString(values),
                     }),
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
                     render: option => Reader.of(option.value.permanentValue),
@@ -142,7 +144,7 @@ const renderOneTimeCostMap = (value) => {
             return renderParameterMap(value.NonModifiable.map, option => Reader.of(option.value), formatEnergyR, value.NonModifiable.map.options.every(option => option.value.permanentValue !== undefined)
                 ? {
                     format: values => translateR(", {$value} of which are permanent", {
-                        value: values,
+                        value: fixedNumberOrString(values),
                     }),
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
                     render: option => Reader.of(option.value.permanentValue),
@@ -240,10 +242,10 @@ export const renderMagicalActionCost = (cost) => {
         case "FirstPerson":
             return Reader.asks(({ translate }) => translate("{$firstPersonValue} for the first person; {$additionalPersonValue} for each additional person", {
                 firstPersonValue: translate("{$value} AE", {
-                    value: cost.FirstPerson.value,
+                    value: cost.FirstPerson.value.toFixed(),
                 }),
                 additionalPersonValue: translate("{$value} AE", {
-                    value: cost.FirstPerson.value / 2,
+                    value: (cost.FirstPerson.value / 2).toFixed(),
                 }),
             }));
         case "ByPrimaryPatron":
@@ -252,7 +254,7 @@ export const renderMagicalActionCost = (cost) => {
             return Reader.asks(({ translate }) => cost.All.minimum === undefined
                 ? translate("All AE")
                 : translate("All AE, at least {$value} AE", {
-                    value: cost.All.minimum,
+                    value: cost.All.minimum.toFixed(),
                 }));
         case "Map":
             return renderStandaloneCostMap(cost.Map);

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

@@ -1,6 +1,6 @@
 import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { translateFnR } from "../../reader.js";
+import { fixedNumberOrString, translateFnR } from "../../reader.js";
 const getContentPartsForQualityLevels = (getQualityLevelString, source) => translateFnR.map((translate) => ({
     label: translate("Effect"),
     value: [
@@ -13,7 +13,7 @@ const getContentPartsForQualityLevels = (getQualityLevelString, source) => trans
             style: "hidden",
             items: source.quality_levels.map((text, index) => ({
                 label: translate("QL {$value}", {
-                    value: getQualityLevelString(index),
+                    value: fixedNumberOrString(getQualityLevelString(index)),
                 }),
                 value: text,
             })),

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

@@ -1,6 +1,7 @@
 import { Reader } from "@elyukai/utils/reader";
 import type { ChildEntityMap, EntityMap, FastSkillModificationLevelConfig, ResponsiveText, ResponsiveTextOptional, SkillModificationLevel, SlowSkillModificationLevelConfig } from "@optolith/database-schema/gen";
 import type { IdArgsVariant } from "tsondb/schema/gen";
+import type { StdReader } from "../../env.js";
 import type { GetAllChildInstancesForParent, GetAllInstances, GetInstanceById } from "../../helpers/getTypes.js";
 import type { LocaleCompare, LocaleJoin, LocaleJoinType } from "../../helpers/locale.js";
 import type { Format, LocaleMap, Translate, TranslateMap, TranslationKeyMatchingParamsOfKey, TranslationParamsInArray, Translations } from "../../helpers/translate.js";
@@ -99,7 +100,7 @@ export declare const attributedNameFromInstanceR: (instance: {
     translations: LocaleMap<{
         name: string;
     }>;
-} | undefined, context: string, ...args: IdArgsVariant) => Reader<{
+} | undefined, context: string, ...args: IdArgsVariant<EntityMap, keyof EntityMap>) => Reader<{
     translateMap: TranslateMap;
 }, string | undefined>;
 /**
@@ -204,6 +205,13 @@ export declare const responsiveTranslateR: <K extends keyof Translations, K2 ext
     translate: Translate;
     responsiveTextSize: ResponsiveTextSize;
 }, string>;
+/**
+ * Creates a responsive value from a translation key that has a full and a compressed version.
+ */
+export declare const responsiveTranslateSplitR: <K extends keyof Translations, K2 extends TranslationKeyMatchingParamsOfKey<K>>(fullKey: K, compressedKey: K2, ...rest: [...TranslationParamsInArray<K>, ...TranslationParamsInArray<K2>]) => Reader<{
+    translate: Translate;
+    responsiveTextSize: ResponsiveTextSize;
+}, string>;
 /**
  * Creates a responsive value from a responsive text.
  */
@@ -266,4 +274,20 @@ export declare const mapNullableR: <T, U, R>(defaultValue: U, fn: (value: NonNul
  * Use `Reader` instances directly in a template string.
  */
 export declare const sequence: <E>(string: TemplateStringsArray, ...values: (Reader<E, string> | string)[]) => Reader<E, string>;
+/**
+ * Formats a number according to the locale’s rules, returns a string as-is.
+ */
+export declare const formatNumber: (value: number) => StdReader<string, "fn">;
+/**
+ * Formats an AP value in an appreviated form.
+ */
+export declare const formatAPValue: (value: number) => StdReader<string, "t" | "fn">;
+/**
+ * Formats a number according to the locale’s rules, returns a string as-is.
+ */
+export declare const formatNumberOrString: (value: number | string) => StdReader<string, "fn">;
+/**
+ * Formats a number in fixed-point notation, returns a string as-is.
+ */
+export declare const fixedNumberOrString: (value: number | string, fractionDigits?: number) => string;
 export {};

package/lib/entities/partial/reader.js

@@ -135,6 +135,10 @@ export const responsiveThenR = (full, compressed) => Reader.asks(env => {
  * Creates a responsive value from a translation key that has a full and a compressed version.
  */
 export const responsiveTranslateR = (fullKey, compressedKey, ...rest) => Reader.asks(({ translate, responsiveTextSize }) => responsive(responsiveTextSize, () => translate(fullKey, ...rest), () => translate(compressedKey, ...rest)));
+/**
+ * Creates a responsive value from a translation key that has a full and a compressed version.
+ */
+export const responsiveTranslateSplitR = (fullKey, compressedKey, ...rest) => Reader.asks(({ translate, responsiveTextSize }) => responsive(responsiveTextSize, () => translate(fullKey, ...rest.slice(0, 1)), () => translate(compressedKey, ...rest.slice(1))));
 /**
  * Creates a responsive value from a responsive text.
  */
@@ -198,3 +202,19 @@ export const mapNullableR = (defaultValue, fn) => (value) => isNotNullish(value)
  * 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] ?? ""), ""));
+/**
+ * Formats a number according to the locale’s rules, returns a string as-is.
+ */
+export const formatNumber = (value) => Reader.asks(env => env.formatNumber(value));
+/**
+ * Formats an AP value in an appreviated form.
+ */
+export const formatAPValue = (value) => formatNumber(value).thenW(formattedValue => translateR("{$value} AP", { value: formattedValue }));
+/**
+ * Formats a number according to the locale’s rules, returns a string as-is.
+ */
+export const formatNumberOrString = (value) => Reader.asks(env => (typeof value === "number" ? env.formatNumber(value) : value));
+/**
+ * Formats a number in fixed-point notation, returns a string as-is.
+ */
+export const fixedNumberOrString = (value, fractionDigits) => typeof value === "number" ? value.toFixed(fractionDigits) : value;

package/lib/entities/partial/units/energy.js

@@ -1,3 +1,4 @@
+import { fixedNumberOrString } from "../reader.js";
 const lengthUnitTranslationKeys = {
     LifePoints: "{$value} LP",
     ArcaneEnergy: "{$value} AE",
@@ -8,5 +9,5 @@ const lengthUnitTranslationKeys = {
  */
 export const formatEnergy = (translate, unit, value) => {
     const key = lengthUnitTranslationKeys[unit];
-    return translate(key, { value });
+    return translate(key, { value: fixedNumberOrString(value) });
 };

package/lib/entities/partial/units/length.js

@@ -1,4 +1,5 @@
 import { Reader } from "@elyukai/utils/reader";
+import { fixedNumberOrString } from "../reader.js";
 import { responsive } from "../responsiveText.js";
 const lengthUnitTranslationKeys = {
     Steps: [".input {$value :number} {{{$value} yards}}", "{$value} yards", "{$value} yd"],
@@ -9,9 +10,11 @@ const lengthUnitTranslationKeys = {
  */
 export const formatLength = (translate, responsiveTextSize, unit, value) => {
     const [fullNumberKey, fullKey, compressedKey] = lengthUnitTranslationKeys[typeof unit === "string" ? unit : unit.kind];
-    return responsive(responsiveTextSize, () => translate(typeof value === "number" ? fullNumberKey : fullKey, {
-        value,
-    }), () => translate(compressedKey, { value }));
+    return responsive(responsiveTextSize, () => translate(typeof value === "number" ? fullNumberKey : fullKey, typeof value === "number"
+        ? {
+            value,
+        }
+        : { value }), () => translate(compressedKey, { value: fixedNumberOrString(value) }));
 };
 /**
  * Returns the text for a length unit.

package/lib/entities/partial/units/timeSpan.js

@@ -35,13 +35,17 @@ export const formatTimeSpan = (translate, translateMap, format, responsiveTextSi
         }));
     }
     const [fullNumberKey, fullKey, compressedNumberKey, compressedKey] = timeSpanUnitTranslationKeys[typeof unit === "string" ? unit : unit.kind];
-    return responsive(responsiveTextSize, () => translate(typeof value === "number" ? fullNumberKey : fullKey, {
-        value,
-        style: interval ? "interval" : "default",
-    }), () => translate(typeof value === "number" ? compressedNumberKey : compressedKey, {
-        value,
-        style: interval ? "interval" : "default",
-    }));
+    return responsive(responsiveTextSize, () => translate(typeof value === "number" ? fullNumberKey : fullKey, typeof value === "number"
+        ? {
+            value,
+            style: interval ? "interval" : "default",
+        }
+        : { value }), () => translate(typeof value === "number" ? compressedNumberKey : compressedKey, typeof value === "number"
+        ? {
+            value,
+            style: interval ? "interval" : "default",
+        }
+        : { value }));
 };
 /**
  * Returns the text for a time span unit.

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

@@ -6,3 +6,7 @@ export declare const MISSING_VALUE = "###MISSING###";
  * String to display when a translation that should be present produces an error.
  */
 export declare const UNHANDLED_VALUE = "###UNHANDLEDERROR###";
+/**
+ * String to display when there is a logic error in text generation.
+ */
+export declare const LOGIC_ERROR = "###LOGIC_ERROR###";

package/lib/entities/partial/unknown.js

@@ -6,3 +6,7 @@ export const MISSING_VALUE = "###MISSING###";
  * String to display when a translation that should be present produces an error.
  */
 export const UNHANDLED_VALUE = "###UNHANDLEDERROR###";
+/**
+ * String to display when there is a logic error in text generation.
+ */
+export const LOGIC_ERROR = "###LOGIC_ERROR###";

package/lib/entities/poison.js

@@ -379,7 +379,7 @@ export const getPoisonEntityDescription = createEntityDescriptionCreator(({ getI
                         ? undefined
                         : {
                             label: `${translate("AP Value")} (${translate("Trade Secret")})`,
-                            value: translate("{$value} AP", { value: tradeSecret.apValue }) +
+                            value: translate("{$value} AP", { value: tradeSecret.apValue.toFixed() }) +
                                 parensIf(mapNullable(tradeSecret.prerequisites, prerequisites => `${translate("Prerequisites")}: ${printPlainGeneralPrerequisites(prerequisites).run(env)}`)),
                         },
                     entry.source_type.kind === "AlchemicalPoison" ||

package/lib/entities/profession.js

@@ -2,7 +2,7 @@ import { allSame } from "@elyukai/utils/array/filters";
 import { ensureNonEmpty, isEmpty, isNotEmpty, } from "@elyukai/utils/array/nonEmpty";
 import { deepEqual, equal } from "@elyukai/utils/equality";
 import { on } from "@elyukai/utils/function";
-import { isNotNullish, isNullish, mapNullable, nullableToArray, } from "@elyukai/utils/nullable";
+import { isNotNullish, isNullish, mapNullable } from "@elyukai/utils/nullable";
 import { omitKeys } from "@elyukai/utils/object";
 import { compareNumber } from "@elyukai/utils/ordering";
 import { Reader } from "@elyukai/utils/reader";
@@ -13,16 +13,13 @@ import { combineNameComponents, getNameComponents, renderActivatableNameComponen
 import { renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
 import { attributedCustomName, attributedInstance, attributedName, attributedNameFromInstance, } from "./partial/markdown.js";
 import { printProfessionPrerequisites, printProfessionVariantPrerequisites, } from "./partial/prerequisites/index.js";
+import { renderBaseCombatTechniquesForAdventurePointsOption, renderVariantCombatTechniquesForAdventurePointsOption, } from "./partial/profession/options/combatTechniquesForAdventurePoints.js";
+import { renderBaseNumberOfSpellworksTotalingAdventurePoints, renderVariantNumberOfSpellworksTotalingAdventurePoints, } from "./partial/profession/options/numberOfSpellworksTotalingAdventurePoints.js";
+import { prepareProfessionPackages, } from "./partial/profession/packages.js";
+import { insteadOfR, renderVariantOption, renderVariantOptionPaths, } from "./partial/profession/variants.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
-import { attributedCustomNameR, attributedNameR, customNameR, formatR, getChildInstancesForInstanceIdFnR, getChildInstancesForInstanceIdR, getInstanceByIdR, localeCompareR, localeJoinR, localeSortR, strictNameR, translateMapFnR, translateR, translationR, } from "./partial/reader.js";
+import { attributedCustomNameR, attributedNameR, customNameR, fixedNumberOrString, formatAPValue, formatR, getChildInstancesForInstanceIdFnR, getChildInstancesForInstanceIdR, getInstanceByIdR, localeCompareR, localeJoinR, localeSortR, strictNameR, translateMapFnR, translateR, translationR, } from "./partial/reader.js";
 import { MISSING_VALUE, UNHANDLED_VALUE } from "./partial/unknown.js";
-const prepareProfessionPackages = (professionId) => Reader.asks(({ getInstanceById, getChildInstancesForInstanceId }) => getChildInstancesForInstanceId("ProfessionPackage", professionId)
-    .map((professionPackage) => ({
-    ...professionPackage,
-    experienceLevel: getInstanceById("ExperienceLevel", professionPackage.content.experience_level),
-}))
-    .filter((professionPackage) => professionPackage.experienceLevel !== undefined)
-    .toSorted(on(item => item.experienceLevel.adventure_points, compareNumber)));
 const renderNumericListAcrossPackages = (packages, selector, equalityFn, renderText, defaultValue) => packages
     .reduce((accR, pkg, pkgIndex) => accR.map2(selector(pkg), (acc, selected) => selected.reduce((filledAcc, [values, number]) => {
     const existing = filledAcc.findIndex(([value]) => equalityFn(value, values));
@@ -48,7 +45,6 @@ const renderNumericListAcrossPackages = (packages, selector, equalityFn, renderT
     .thenW(list => localeSortR(list))
     .map(list => ensureNonEmpty(list)?.join(", "));
 const renderSinglePackageValue = (professionPackages, selector, equalityFn, renderText) => Reader.traverse(professionPackages, selector).thenW(selected => (allSame(selected, equalityFn) ? renderText([selected[0]]) : renderText(selected)));
-const insteadOfR = (replacement, base) => translateR("{$replacement} instead of {$base}", { replacement, base });
 /**
  * If the selected values of the base and the variant are equal, only renders the value once. Otherwise, renders both values as the variant value replacing the base value.
  */
@@ -59,23 +55,14 @@ const plainOrInsteadOfR = (base, variant, selector, equality, render) => {
         ? render(baseValue)
         : render(variantValue).thenW(replacement => render(baseValue).thenW(baseRendered => insteadOfR(replacement, baseRendered)));
 };
-const renderVariantOptionPaths = (base, variant, paths) => {
-    switch (variant.kind) {
-        case "Remove":
-            return base === undefined ? Reader.of(MISSING_VALUE) : paths.remove(base);
-        case "Override":
-            return base === undefined ? paths.add(variant.Override) : paths.update(base, variant.Override);
-        default:
-            return assertExhaustive(variant);
-    }
-};
 const renderVariantLanguagesScriptsOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
-    remove: base => translateR("no Languages and Literacy totaling {$apValue} AP", { apValue: base.ap_value }),
-    add: override => translateR("Languages and Literacy totaling {$apValue} AP", { apValue: override.ap_value }),
-    update: (base, override) => translateR("{$replacement} instead of {$base}", {
-        replacement: override.ap_value,
-        base: base.ap_value,
-    }).then(apValue => translateR("Languages and Literacy totaling {$apValue} AP", {
+    remove: base => translateR("no Languages and Literacy totaling {$apValue} AP", {
+        apValue: base.ap_value.toFixed(),
+    }),
+    add: override => translateR("Languages and Literacy totaling {$apValue} AP", {
+        apValue: override.ap_value.toFixed(),
+    }),
+    update: (base, override) => insteadOfR(override.ap_value, base.ap_value).then(apValue => translateR("Languages and Literacy totaling {$apValue} AP", {
         apValue,
     })),
 });
@@ -101,17 +88,17 @@ const renderSkillSpecializationOption = (option) => Reader.asks(({ format, trans
 const renderCombatTechniquesOption = (option) => isNotEmpty(option.fixed)
     ? (() => {
         const [first, ...others] = option.fixed;
-        const firstTextR = translateR(".input {$count :number} {{{$count} of the following combat techniques {$rating}}}", { count: first.number, rating: first.rating_modifier + 6 });
+        const firstTextR = translateR(".input {$count :number} {{{$count} of the following combat techniques {$rating}}}", { count: first.number, rating: (first.rating_modifier + 6).toFixed() });
         const fixedTextR = others.reduce((accTextR, other) => accTextR.then(accText => translateR(".input {$count :number} {{{$previous}, {$count} others {$rating}}}", {
             count: other.number,
             previous: accText,
-            rating: other.rating_modifier + 6,
+            rating: (other.rating_modifier + 6).toFixed(),
         })), firstTextR);
         const completeTextR = fixedTextR.then(fixedText => option.rest_rating_modifier === undefined
             ? Reader.of(fixedText)
             : translateR("{$previous}, the others {$rating}", {
                 previous: fixedText,
-                rating: option.rest_rating_modifier + 6,
+                rating: (option.rest_rating_modifier + 6).toFixed(),
             }));
         const listR = Reader.traverse(option.options, id => attributedNameR("profession", id).map(name => name ?? MISSING_VALUE))
             .thenW(list => localeSortR(list))
@@ -134,13 +121,13 @@ const renderSkillsOption = (professionPackages, skillGroup) => allSame(professio
         ? pkg.content.options.skills
         : undefined), apValue => professionPackages[0].content.options?.skills?.specific === undefined
         ? translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
-            apValue,
+            apValue: fixedNumberOrString(apValue),
             skillsOfGroup: skillGroup.nameOfSkillsOfGroup,
         })
         : Reader.traverse(professionPackages[0].content.options.skills.specific, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE))
             .thenW(localeSortR)
-            .thenW(list => translateR("maximum SR per skill: {$maxSR}", { maxSR: 8 }).then(maxSRText => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
-            apValue,
+            .thenW(list => translateR("maximum SR per skill: {$maxSR}", { maxSR: "8" }).then(maxSRText => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
+            apValue: fixedNumberOrString(apValue),
             list: list.join(", ") + parensIf(maxSRText),
         })))) ?? Reader.of(undefined))
     : Reader.traverse(professionPackages, pkg => {
@@ -149,13 +136,13 @@ const renderSkillsOption = (professionPackages, skillGroup) => allSame(professio
             ? Reader.of("—")
             : skillsOption.specific === undefined
                 ? translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
-                    apValue: skillsOption.ap_value,
+                    apValue: skillsOption.ap_value.toFixed(),
                     skillsOfGroup: skillGroup.nameOfSkillsOfGroup,
                 })
                 : Reader.traverse(skillsOption.specific, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE))
                     .thenW(localeSortR)
-                    .thenW(list => translateR("maximum SR per skill: {$maxSR}", { maxSR: 8 }).then(maxSRText => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
-                    apValue: skillsOption.ap_value,
+                    .thenW(list => translateR("maximum SR per skill: {$maxSR}", { maxSR: "8" }).then(maxSRText => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
+                    apValue: skillsOption.ap_value.toFixed(),
                     list: list.join(", ") + parensIf(maxSRText),
                 })));
     }).map(list => list.join(" / "));
@@ -175,10 +162,7 @@ const renderVariantCantripsOption = (baseOptions, variantOptions) => renderVaria
         }).then(baseCount => translateR(".input {$count :number} {{{$count} cantrips}}", {
             count: override.number,
         })
-            .then(replacementCount => translateR("{$replacement} instead of {$base}", {
-            replacement: replacementCount,
-            base: baseCount,
-        }).then(count => translateR("{$count} from the following list", { count })))
+            .then(replacementCount => insteadOfR(replacementCount, baseCount).then(count => translateR("{$count} from the following list", { count })))
             .map(text => `${text}: ${list}`)))
         : renderCantripList(override.options)
             .thenW(list => translateR(".input {$count :number} {{{$count} cantrips}}", {
@@ -192,10 +176,7 @@ const renderVariantCantripsOption = (baseOptions, variantOptions) => renderVaria
         })
             .then(count => translateR("{$count} from the following list", { count }))
             .map(text => `${text}: ${list}`))
-            .then(baseText => translateR("{$replacement} instead of {$base}", {
-            replacement: replacementText,
-            base: baseText,
-        }))),
+            .then(baseText => insteadOfR(replacementText, baseText))),
 });
 const renderSingleCantripsOption = (option) => renderVariantCantripsOption(undefined, { kind: "Override", Override: option });
 const renderCantripsOption = (professionPackages) => {
@@ -212,7 +193,7 @@ const renderCantripsOption = (professionPackages) => {
     }
 };
 const renderLiturgiesOption = (professionPackages) => mapNullable(getTotalingAPValues(professionPackages, pkg => pkg.content.options?.liturgies), apValue => translateR("Liturgies totaling {$apValue} AP", {
-    apValue,
+    apValue: fixedNumberOrString(apValue),
 })) ?? Reader.of(undefined);
 const renderVariantSkillSpecializationOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
     remove: (base) => {
@@ -260,8 +241,8 @@ const renderVariantCombatTechniquesOption = (baseOptions, variantOptions) => ren
     update: (base, override) => renderCombatTechniquesOption(override).then(overrideText => renderCombatTechniquesOption(base).then(baseText => insteadOfR(overrideText, baseText))),
 });
 const renderVariantCursesOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
-    remove: base => translateR("no Curses totaling {$apValue} AP", { apValue: base.ap_value }),
-    add: override => translateR("Curses totaling {$apValue} AP", { apValue: override.ap_value }),
+    remove: base => translateR("no Curses totaling {$apValue} AP", { apValue: base.ap_value.toFixed() }),
+    add: override => translateR("Curses totaling {$apValue} AP", { apValue: override.ap_value.toFixed() }),
     update: (base, override) => insteadOfR(override.ap_value, base.ap_value).then(apValue => translateR("Curses totaling {$apValue} AP", {
         apValue,
     })),
@@ -273,17 +254,17 @@ const renderVariantSkillsOption = (baseOptions, variantOptions) => renderVariant
         skillsOfGroup: nameOfSkillsOfGroup,
     })),
     add: override => nameOfSkillsOfGroupR(override.group).thenW(nameOfSkillsOfGroup => translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
-        apValue: override.ap_value,
+        apValue: override.ap_value.toFixed(),
         skillsOfGroup: nameOfSkillsOfGroup,
     })),
     update: (base, override) => plainOrInsteadOfR(base, override, b => b.ap_value, equal, b => Reader.of(b)).thenW(apValue => plainOrInsteadOfR(base, override, b => b.group, equal, nameOfSkillsOfGroupR).thenW(nameOfSkillsOfGroup => translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
-        apValue,
-        skillsOfGroup: nameOfSkillsOfGroup,
+        apValue: fixedNumberOrString(apValue),
+        skillsOfGroup: fixedNumberOrString(nameOfSkillsOfGroup),
     }))),
 });
 const renderVariantLiturgiesOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
-    remove: base => translateR("no Liturgies totaling {$apValue} AP", { apValue: base.ap_value }),
-    add: override => translateR("Liturgies totaling {$apValue} AP", { apValue: override.ap_value }),
+    remove: base => translateR("no Liturgies totaling {$apValue} AP", { apValue: base.ap_value.toFixed() }),
+    add: override => translateR("Liturgies totaling {$apValue} AP", { apValue: override.ap_value.toFixed() }),
     update: (base, override) => insteadOfR(override.ap_value, base.ap_value).then(apValue => translateR("Liturgies totaling {$apValue} AP", {
         apValue,
     })),
@@ -416,6 +397,9 @@ const renderCombatTechniques = (professionPackages) => Reader.sequence([
     professionPackages.some(pkg => pkg.content.options?.combat_techniques !== undefined)
         ? renderSinglePackageValue(professionPackages, pkg => Reader.of(pkg.content.options?.combat_techniques), deepEqual, options => Reader.traverse(options, option => option === undefined ? Reader.of("—") : renderCombatTechniquesOption(option)).map(renderedOptions => renderedOptions.join(" / ")))
         : Reader.of(undefined),
+    professionPackages.some(pkg => pkg.content.options?.combatTechniquesForAdventurePoints !== undefined)
+        ? renderBaseCombatTechniquesForAdventurePointsOption(professionPackages)
+        : Reader.of(undefined),
 ]).map(list => ensureNonEmpty(list.filter(isNotNullish))?.join(", ") ?? "—");
 const renderSkills = (professionPackages) => Reader.asks(({ getAllInstances }) => getAllInstances("SkillGroup")).thenW(skillGroups => Reader.traverse(skillGroups.toSorted(on(group => group.content.position, compareNumber)), ({ id: groupId, content: group }) => translationR(group).thenW(groupTranslation => Reader.sequence([
     renderNumericListAcrossPackages(professionPackages, pkg => Reader.asks(({ getInstanceById }) => pkg.content.skills
@@ -444,6 +428,9 @@ const renderSpellworkName = (spellworkIds) => Reader.traverse(spellworkIds, spel
 const renderSpellworks = (professionPackages) => Reader.sequence([
     renderCantripsOption(professionPackages),
     renderNumericListAcrossPackages(professionPackages, (pkg) => Reader.of(pkg.content.spells?.map(ct => [ct.id, ct.rating_modifier]) ?? []), deepEqual, renderSpellworkName, undefined),
+    professionPackages.some(pkg => pkg.content.options?.spellworks !== undefined)
+        ? renderBaseNumberOfSpellworksTotalingAdventurePoints(professionPackages)
+        : Reader.of(undefined),
 ]).map(list => ensureNonEmpty(list.filter(isNotNullish))?.join("; "));
 const retrieveBlessedTraditionIdentifierFromPrerequisiteGroup = (prerequisite) => prerequisite.kind === "Activatable" && prerequisite.Activatable.id.kind === "BlessedTradition"
     ? [prerequisite.Activatable.id.BlessedTradition]
@@ -533,17 +520,9 @@ const renderRatedVariantChanges = (baseList, variantList, renderInstance) => Rea
         return renderInstance(id).map(name => `${name} ${rating_modifier.toFixed()}`);
     }
     const baseValue = baseList?.find(item => deepEqual(item.id, id))?.rating_modifier ?? 0;
-    return renderInstance(id).thenW(name => translateR("{$replacement} instead of {$base}", {
-        replacement: `${name} ${(baseValue + rating_modifier).toFixed()}`,
-        base: baseValue,
-    }));
+    return renderInstance(id).thenW(name => insteadOfR(`${name} ${(baseValue + rating_modifier).toFixed()}`, baseValue));
 }).thenW(localeSortR);
-const renderVariantOption = (base, variant, key, render) => (variant.options?.[key] === undefined
-    ? Reader.of(undefined)
-    : render(base.options?.[key], variant.options[key])).map(text => nullableToArray(text));
-const renderProfessionVariantLabel = (base, variant, translations) => translateR("{$value} AP", {
-    value: base.ap_value + (variant.ap_value ?? 0),
-}).thenW(apValueText => localeSortR(translations.map(({ id, content }) => `^[${content.name.default}](entity: "ProfessionVariant", instance: "${id}")`))
+const renderProfessionVariantLabel = (base, variant, translations) => formatAPValue(base.ap_value + (variant.ap_value ?? 0)).thenW(apValueText => localeSortR(translations.map(({ id, content }) => `^[${content.name.default}](entity: "ProfessionVariant", instance: "${id}")`))
     .thenW(list => localeJoinR(list, "conjunction"))
     .map(names => names + parensIf(apValueText)));
 const renderProfessionVariantText = (base, variant, translation) => translation.full_text !== undefined
@@ -557,9 +536,11 @@ const renderProfessionVariantText = (base, variant, translation) => translation.
         renderVariantOption(base, variant, "skill_specialization", renderVariantSkillSpecializationOption),
         renderVariantOption(base, variant, "languages_scripts", renderVariantLanguagesScriptsOption),
         renderVariantOption(base, variant, "combat_techniques", renderVariantCombatTechniquesOption),
+        renderVariantOption(base, variant, "combatTechniquesForAdventurePoints", renderVariantCombatTechniquesForAdventurePointsOption),
         renderVariantOption(base, variant, "cantrips", renderVariantCantripsOption),
         renderVariantOption(base, variant, "curses", renderVariantCursesOption),
         renderVariantOption(base, variant, "skills", renderVariantSkillsOption),
+        renderVariantOption(base, variant, "spellworks", renderVariantNumberOfSpellworksTotalingAdventurePoints),
         renderVariantOption(base, variant, "liturgies", renderVariantLiturgiesOption),
         variant.special_abilities === undefined
             ? Reader.of([])
@@ -635,10 +616,11 @@ const renderProfessionVariants = (professionPackages) => professionPackages.leng
  * Get a JSON representation of the rules text for a profession version.
  */
 export const getProfessionVersionEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getAllInstances, getChildInstancesForInstanceId, getResolvedSelectOptionById, }, locale, { id, content: entry }) => {
-    const { format, translate, translateMap, compare: localeCompare, join: localeJoin } = locale;
+    const { format, formatNumber, translate, translateMap, compare: localeCompare, join: localeJoin, } = locale;
     const translation = translateMap(entry.translations);
     const env = {
         format,
+        formatNumber,
         translate,
         translateMap,
         localeCompare,