@optolith/entity-descriptions 0.13.1 → 0.14.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 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.14.0](https://github.com/Optolith/entity-descriptions/compare/v0.13.2...v0.14.0) (2026-09-24)
+
+### ⚠ BREAKING CHANGES
+
+* **deps:** upgrade to schema 0.65.0
+
+### build
+
+* **deps:** upgrade to schema 0.65.0 ([cb94c96](https://github.com/Optolith/entity-descriptions/commit/cb94c96df8dc3f1d4f5476db729df2ed85ce6b1d))
+
+### Bug Fixes
+
+* missing adventure points label for AP value by level ([9aabd43](https://github.com/Optolith/entity-descriptions/commit/9aabd437d587e7b559c18a730249ea3c66bb8387))
+## [0.13.2](https://github.com/Optolith/entity-descriptions/compare/v0.13.1...v0.13.2) (2026-09-16)
+
+### Features
+
+* add focus rule badges to activatable entries, spellworks and liturgical chants and ceremonies ([dd142b4](https://github.com/Optolith/entity-descriptions/commit/dd142b47f3cd29620d29a2561e4a8ae8ad1d2a2d)), closes [#41](https://github.com/Optolith/entity-descriptions/issues/41)
 ## [0.13.1](https://github.com/Optolith/entity-descriptions/compare/v0.13.0...v0.13.1) (2026-09-16)
 
 ### Bug Fixes

package/lib/creator.js

@@ -64,7 +64,7 @@ export const createEntityDescriptionCreator = (fn) => (databaseAccessors, locale
         ...rawEntry,
         body: rawEntry.body.filter(isNotNullish).map(mapRawSection),
         errata: rawEntry.errata?.map(({ date, description }) => ({
-            date: locale.formatDate(date),
+            date: locale.formatDate(new Date(date)),
             description: description.trim(),
         })),
         references: rawEntry.references === undefined

package/lib/entities/activatable.d.ts

@@ -51,7 +51,7 @@ export type BaseActivatableTranslation = {
  * Get a JSON representation of the rules text for a special ability.
  */
 export declare const getActivatableEntityDescription: import("../creator.js").EntityDescriptionCreator<"Advantage" | "Disadvantage" | "AdvancedCombatSpecialAbility" | "AdvancedKarmaSpecialAbility" | "AdvancedMagicalSpecialAbility" | "AdvancedSkillSpecialAbility" | "AncestorGlyph" | "ArcaneOrbEnchantment" | "AttireEnchantment" | "Beutelzauber" | "BlessedTradition" | "BowlEnchantment" | "BrawlingSpecialAbility" | "CauldronEnchantment" | "CeremonialItemSpecialAbility" | "ChronicleEnchantment" | "CombatSpecialAbility" | "CombatStyleSpecialAbility" | "CommandSpecialAbility" | "DaggerRitual" | "FamiliarSpecialAbility" | "FatePointSexSpecialAbility" | "FatePointSpecialAbility" | "FoolsHatEnchantment" | "GeneralSpecialAbility" | "Haubenzauber" | "Hauerkettenzauber" | "InstrumentEnchantment" | "KarmaSpecialAbility" | "Keulenzauber" | "Krallenkettenzauber" | "Kristallkugelzauber" | "LiturgicalStyleSpecialAbility" | "LycantropicGift" | "MagicalSign" | "MagicalSpecialAbility" | "MagicalTradition" | "MagicStyleSpecialAbility" | "OrbEnchantment" | "PactGift" | "ProtectiveWardingCircleSpecialAbility" | "RingEnchantment" | "Schweinetrommelzauber" | "Sermon" | "SexSpecialAbility" | "SickleRitual" | "SikaryanDrainSpecialAbility" | "SkillStyleSpecialAbility" | "SpellSwordEnchantment" | "StaffEnchantment" | "ToyEnchantment" | "Trinkhornzauber" | "VampiricGift" | "Vision" | "WandEnchantment" | "WeaponEnchantment", {
-    getInstanceById: GetInstanceById<"Publication" | "Subject" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "TradeSecret" | "Aspect" | "Property" | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Weapon" | "Patron" | "PersonalityTrait" | "Brew" | "Blessing" | "Cantrip">;
+    getInstanceById: GetInstanceById<"Publication" | "Subject" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "TradeSecret" | "Aspect" | "Property" | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Weapon" | "Patron" | "PersonalityTrait" | "Brew" | "Blessing" | "Cantrip" | "FocusRule">;
     getAllInstances: GetAllInstances<"Script">;
     getResolvedSelectOptionById: GetResolvedSelectOptionById;
     getAllResolvedSelectOptions: GetAllResolvedSelectOptions;

package/lib/entities/activatable.js

@@ -18,7 +18,7 @@ import { renderAdventurePointsValue } from "./partial/adventurePointsValue.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";
+import { getDerivedFocusRuleBadgeFromPrerequisites, printAdvantageDisadvantagePrerequisites, printGeneralPrerequisites, } from "./partial/prerequisites/index.js";
 import { printActivatableName, } from "./partial/prerequisites/single/activatable.js";
 import { renderStandaloneCostMap } from "./partial/rated/activatable/cost.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
@@ -44,6 +44,10 @@ const renderAdvantageDisadvantageSubtype = (subtype) => {
             return translateR("Magical Rank");
         case "MagicalTitle":
             return translateR("Magical Title");
+        case "BlessedRank":
+            return translateR("Blessed Title");
+        case "BlessedTitle":
+            return translateR("Blessed Title");
         default:
             return assertExhaustive(subtype);
     }
@@ -311,7 +315,9 @@ const renderVolumeValue = (translate, translateMap, getAllResolvedSelectOptions,
                 levels: volume.ByLevel.list.map((_, index) => romanize(index + 1)).join("/"),
             });
         case "Map":
-            return renderParameterMap(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: typeof values === "number" ? values.toFixed() : values,
+            })).run({
                 translate,
                 translateMap,
                 responsiveTextSize,
@@ -342,7 +348,7 @@ const renderArcaneEnergyCost = (translate, translateMap, format, localeJoin, res
                 ? value => translate(".input {$value :number} {{{$value} permanent AE}}", {
                     value,
                 })
-                : value => translate("{$value} AE", { value });
+                : value => translate("{$value} AE", { value: value.toFixed() });
             const { interval } = cost.Fixed;
             const wrapInInterval = interval === undefined
                 ? str => str
@@ -370,40 +376,40 @@ const renderArcaneEnergyCost = (translate, translateMap, format, localeJoin, res
             return wrapInPerLevel(value => wrapInInterval(translationWrapper(value))) + noteInParens;
         }
         case "Constant":
-            return (translate("{$value} AE", { value: cost.Constant.value }) +
+            return (translate("{$value} AE", { value: cost.Constant.value.toFixed() }) +
                 (cost.Constant.permanent_value === undefined
                     ? ""
                     : translate(", {$value} of which are permanent", {
-                        value: cost.Constant.permanent_value,
+                        value: cost.Constant.permanent_value.toFixed(),
                     })));
         case "PerCountable": {
             const translation = translateMap(cost.PerCountable.translations);
             return ((cost.PerCountable.base_value === undefined
                 ? ""
-                : `${translate("{$value} AE", { value: cost.PerCountable.base_value })} + `) +
+                : `${translate("{$value} AE", { value: cost.PerCountable.base_value.toFixed() })} + `) +
                 translate("{$cost} per {$countable}", {
-                    cost: translate("{$value} AE", { value: cost.PerCountable.value }),
+                    cost: translate("{$value} AE", { value: cost.PerCountable.value.toFixed() }),
                     countable: getResponsiveText(translation?.per, responsiveTextSize),
                 }) +
                 parensIf(mapNullable(translation?.note, note => getResponsiveTextOptional(note, responsiveTextSize))));
         }
         case "Interval":
             return translate("{$cost} per {$interval}", {
-                cost: translate("{$value} AE", { value: cost.Interval.value }),
+                cost: translate("{$value} AE", { value: cost.Interval.value.toFixed() }),
                 interval: formatTimeSpan(translate, translateMap, format, responsiveTextSize, cost.Interval.interval.unit, cost.Interval.interval.value, true),
             });
         case "ActivationAndHalfInterval":
             return additionFormatter(translate("{$value} AE", {
-                value: cost.ActivationAndHalfInterval.value,
+                value: cost.ActivationAndHalfInterval.value.toFixed(),
             }) + parensIf(translate("activation")), translate("{$cost} per {$interval}", {
                 cost: translate("{$value} AE", {
-                    value: Math.round(cost.ActivationAndHalfInterval.value / 2),
+                    value: Math.round(cost.ActivationAndHalfInterval.value / 2).toFixed(),
                 }),
                 interval: formatTimeSpan(translate, translateMap, format, responsiveTextSize, cost.ActivationAndHalfInterval.interval.unit, cost.ActivationAndHalfInterval.interval.value, true),
             }));
         case "Indefinite":
             return ((mapNullable(translateMap(cost.Indefinite.translations)?.description, description => getResponsiveText(description, responsiveTextSize)) ?? MISSING_VALUE) +
-                mapNullableDefault(cost.Indefinite.modifier, modifier => ` + ${translate("{$value} AE", { value: modifier.value })}`, ""));
+                mapNullableDefault(cost.Indefinite.modifier, modifier => ` + ${translate("{$value} AE", { value: modifier.value.toFixed() })}`, ""));
         case "Disjunction":
             return translate("{$value} AE", {
                 value: localeJoin(cost.Disjunction.options.map(option => option.value.toFixed() +
@@ -430,7 +436,7 @@ const renderArcaneEnergyCost = (translate, translateMap, format, localeJoin, res
                 case "Verbose":
                     return cost.ByLevel.levels
                         .map((level, index) => translate("{$cost} for level {$level}", {
-                        cost: translate("{$value} AE", { value: level.value }),
+                        cost: translate("{$value} AE", { value: level.value.toFixed() }),
                         level: romanize(index + 1),
                     }))
                         .join("; ");
@@ -454,7 +460,9 @@ const renderBindingCost = (translate, translateMap, localeCompare, getAllResolve
                 }),
             });
         case "Map":
-            return renderParameterMap(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: typeof values === "number" ? values.toFixed() : values,
+            })).run({
                 translate,
                 translateMap,
                 responsiveTextSize,
@@ -481,12 +489,12 @@ const renderBindingCost = (translate, translateMap, localeCompare, getAllResolve
 const renderLifePointsCost = (translate, cost) => cost === undefined
     ? ""
     : // eslint-disable-next-line no-irregular-whitespace
-        ` (+ ${translate("{$value} LP", { value: cost.Fixed.value })})`;
+        ` (+ ${translate("{$value} LP", { value: cost.Fixed.value.toFixed() })})`;
 const renderCost = (translate, translateMap, format, localeJoin, localeCompare, getAllResolvedSelectOptions, responsiveTextSize, levels, cost) => {
     if (typeof cost === "number") {
         return {
             label: translate("AE Cost"),
-            value: translate("{$value} AE", { value: cost }),
+            value: translate("{$value} AE", { value: cost.toFixed() }),
         };
     }
     switch (cost.kind) {
@@ -826,9 +834,10 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
         title: addLevels(makeTraditionName(translation.name_in_library ?? translation.name + parensIf(translation.additionalName))),
         subtitle: mapNullable(baseEntry.subtype, subtype => renderAdvantageDisadvantageSubtype(subtype).run(env)) ??
             mapNullable(baseEntry.usage_type, usageType => renderCombatSpecialAbilityType(usageType).run(env)),
-        badge: mapNullable(entityName === "CombatStyleSpecialAbility" || entityName === "AdvancedCombatSpecialAbility"
+        badge: mapNullable(entityName === "CombatStyleSpecialAbility" ||
+            entityName === "AdvancedCombatSpecialAbility"
             ? entry.type
-            : undefined, combatType => {
+            : undefined, (combatType) => {
             switch (combatType.kind) {
                 case "Armed":
                     return { type: "armedCombat", value: translate("AC") };
@@ -837,7 +846,8 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
                 default:
                     return assertExhaustive(combatType);
             }
-        }),
+        }) ??
+            mapNullable(baseEntry.prerequisites, getDerivedFocusRuleBadgeFromPrerequisites)?.run(env),
         className: "special-ability",
         body: [
             mapNullable(translation.special_rules, specialRules => ({

package/lib/entities/culture.js

@@ -248,14 +248,14 @@ export const getCultureEntityDescription = createEntityDescriptionCreator(({ get
                                 if (allSame(processedScripts, on(([, apValue]) => apValue, equal))) {
                                     return (localeJoin(processedScripts.map(([name]) => name).toSorted(localeCompare), "disjunction") +
                                         parensIf(translate("{$value} AP", {
-                                            value: processedScripts[0][1],
+                                            value: processedScripts[0][1].toFixed(),
                                         })));
                                 }
                                 else {
                                     return localeJoin(processedScripts
                                         .map(([name, apValue]) => name +
                                         parensIf(translate("{$value} AP", {
-                                            value: apValue,
+                                            value: apValue.toFixed(),
                                         })))
                                         .toSorted(localeCompare), "disjunction");
                                 }
@@ -306,7 +306,7 @@ export const getCultureEntityDescription = createEntityDescriptionCreator(({ get
                 type: "labeled",
                 label: translate("Cultural Package {$cultureName}", {
                     cultureName: translation.name,
-                }) + parensIf(translate("{$value} AP", { value: culturalPackageApValue })),
+                }) + parensIf(translate("{$value} AP", { value: culturalPackageApValue.toFixed() })),
                 value: {
                     type: "plain",
                     text: culturePackageText,

package/lib/entities/curriculum.js

@@ -183,7 +183,7 @@ const renderAbilityAdjustment = (translate, translateMap, getInstanceById, baseP
         const printedBaseValue = mapNullable(renderPrintedAbilityAdjustmentBaseValue(abilityAdjustment), value => value + defaultValue);
         return translate("{$replacement} instead of {$base}", {
             base: printedBaseValue === basePoints
-                ? basePoints
+                ? basePoints.toFixed()
                 : `<ins>${basePoints.toFixed()}</ins><del>${printedBaseValue?.toFixed() ?? "n/a"}</del>`,
             replacement: `${renderAbilityAdjustmentName(translateMap, getInstanceById, abilityAdjustment)} ${(basePoints + renderAbilityAdjustmentModifierValue(abilityAdjustment)).toFixed()}`,
         });

package/lib/entities/elixir.js

@@ -54,7 +54,7 @@ export const getElixirEntityDescription = createEntityDescriptionCreator(({ getI
                     {
                         label: `${translate("AP Value")} (${translate("Trade Secret")})`,
                         value: translate("{$value} AP", {
-                            value: entry.trade_secret.ap_value,
+                            value: entry.trade_secret.ap_value.toFixed(),
                         }) +
                             parensIf(mapNullable(entry.trade_secret.prerequisites, prerequisites => `${translate("Prerequisites")}: ${printPlainGeneralPrerequisites(prerequisites).run(env)}`)),
                     },

package/lib/entities/equipment.js

@@ -239,7 +239,7 @@ const renderComplexity = (translate, complexity) => mapNullable(complexity, c =>
                 return translate("Simple");
             case "Complex":
                 return `${translate("Complex")} (${translate("{$value} AP", {
-                    value: c.Complex.ap_value,
+                    value: c.Complex.ap_value.toFixed(),
                 })})`;
             case "Various":
                 return translate("Various");

package/lib/entities/liturgicalChant.d.ts

@@ -12,7 +12,7 @@ export declare const getBlessingEntityDescription: import("../creator.js").Entit
  * Get a JSON representation of the rules text for a liturgical chant.
  */
 export declare const getLiturgicalChantEntityDescription: import("../creator.js").EntityDescriptionCreator<"LiturgicalChant", {
-    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Aspect" | "BlessedTradition" | "DerivedCharacteristic" | RatedIdentifier["kind"] | "Enhancement">;
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Aspect" | "BlessedTradition" | "DerivedCharacteristic" | RatedIdentifier["kind"] | "Enhancement" | "FocusRule">;
     getChildInstancesForInstanceId: GetAllChildInstancesForParent<"Enhancement">;
     idMap: IdMap;
 }, import("../index.js").EntityDescription>;
@@ -20,7 +20,7 @@ export declare const getLiturgicalChantEntityDescription: import("../creator.js"
  * Get a JSON representation of the rules text for a ceremony.
  */
 export declare const getCeremonyEntityDescription: import("../creator.js").EntityDescriptionCreator<"Ceremony", {
-    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Aspect" | "BlessedTradition" | "DerivedCharacteristic" | RatedIdentifier["kind"] | "Enhancement">;
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Aspect" | "BlessedTradition" | "DerivedCharacteristic" | RatedIdentifier["kind"] | "Enhancement" | "FocusRule">;
     getChildInstancesForInstanceId: GetAllChildInstancesForParent<"Enhancement">;
     idMap: IdMap;
 }, import("../index.js").EntityDescription>;

package/lib/entities/liturgicalChant.js

@@ -1,9 +1,11 @@
+import { mapNullable } from "@elyukai/utils/nullable";
 import { isNotNullish } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { Case } from "tsondb/schema/gen";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderEnhancements } from "./partial/enhancements.js";
 import { attributedInstance, attributedName } from "./partial/markdown.js";
+import { getDerivedFocusRuleBadgeFromPrerequisites } from "./partial/prerequisites/index.js";
 import { renderOneTimeDuration } from "./partial/rated/activatable/duration.js";
 import { renderEffect } from "./partial/rated/activatable/effect.js";
 import { combineGeneratedTextWithStaticTranslation, renderFastPerformanceParameters, renderSlowPerformanceParameters, } from "./partial/rated/activatable/index.js";
@@ -173,6 +175,7 @@ export const getLiturgicalChantEntityDescription = createEntityDescriptionCreato
     return {
         title: translation.name,
         className: "liturgical-chant",
+        badge: mapNullable(entry.prerequisites, getDerivedFocusRuleBadgeFromPrerequisites)?.run(env),
         body: [
             {
                 type: "definitionList",
@@ -237,6 +240,7 @@ export const getCeremonyEntityDescription = createEntityDescriptionCreator(({ ge
     return {
         title: translation.name,
         className: "ceremony",
+        badge: mapNullable(entry.prerequisites, getDerivedFocusRuleBadgeFromPrerequisites)?.run(env),
         body: [
             {
                 type: "definitionList",

package/lib/entities/partial/adventurePointsValue.js

@@ -35,7 +35,7 @@ const renderFixedSelectOptionsAdventurePointsValue = (locale, getAllSelectOption
                 .toSorted(locale.compare), "conjunction"),
         ])
             .toSorted(on(item => item[1], locale.compare))
-            .map(([apValue, itemNames]) => `${itemNames}: ${locale.translate("{$value} Adventure Points", { value: typeof apValue === "number" ? applyNegative(apValue) : apValue })}`)
+            .map(([apValue, itemNames]) => `${itemNames}: ${locale.translate("{$value} Adventure Points", { value: typeof apValue === "number" ? applyNegative(apValue).toFixed() : apValue })}`)
             .join("; ");
     }
 };
@@ -88,12 +88,13 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
             if (entry.levels !== value.ByLevel.list.length) {
                 return MISSING_VALUE;
             }
-            const mainValue = `${translate("Level {$level}", {
+            const levelsPrefix = translate("Level {$level}", {
                 level: Array.from({ length: entry.levels }, (_, index) => romanize(index + 1)).join("/"),
-            })}: ${value.ByLevel.list.map(applyNegative).join("/")}`;
+            });
+            const mainValues = value.ByLevel.list.map(applyNegative).join("/");
             const { additionalBySizeCategory } = value.ByLevel;
             if (additionalBySizeCategory === undefined) {
-                return mainValue;
+                return translate("{$value} Adventure Points", { value: mainValues });
             }
             else {
                 const sizeCategories = ["tiny", "small", "medium", "large", "huge"];
@@ -101,7 +102,7 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
                     .map(sizeCategory => applyNegative(additionalBySizeCategory[sizeCategory]))
                     .join("/");
                 const labels = sizeCategories.map(sizeCategory => translate(sizeCategory)).join("/");
-                return `${mainValue} + ${translate("{$values} AP for size category {$labels} (per level)", { values, labels })}`;
+                return `${levelsPrefix}: ${mainValues} + ${translate("{$values} AP for size category {$labels} (per level)", { values, labels })}`;
             }
         }
         case "DerivedFromSelection": {
@@ -281,13 +282,13 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
                     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", {
-                            values,
+                            values: values.join("/"),
                             labels,
                         });
                     }
                     else {
                         return translate("{$values}/and so on Adventure Points for the {$labels}/and so on purchase", {
-                            values,
+                            values: values.join("/"),
                             labels,
                         });
                     }

package/lib/entities/partial/dice.js

@@ -3,11 +3,11 @@ import { translateR } from "./reader.js";
 /**
  * Renders a dice expression like "2D6" into a localized string.
  */
-export const renderDice = (translate, dice) => translate("{$count}D{$sides}", { count: dice.number, sides: dice.sides });
+export const renderDice = (translate, dice) => translate("{$count}D{$sides}", { count: dice.number.toFixed(), sides: dice.sides.toFixed() });
 /**
  * Renders a dice expression like "2D6" into a localized string.
  */
-export const renderDiceR = (dice) => translateR("{$count}D{$sides}", { count: dice.number, sides: dice.sides });
+export const renderDiceR = (dice) => translateR("{$count}D{$sides}", { count: dice.number.toFixed(), sides: dice.sides.toFixed() });
 /**
  * Renders a dice expression with an additional flat modifier, like "2D6+3" or "2D6-1".
  */

package/lib/entities/partial/enhancements.js

@@ -22,8 +22,8 @@ const renderEnhancement = (enhancement, parentImprovementCost) => {
     const { prerequisites } = enhancement.content;
     return translateMapR(enhancement.content.translations).thenW(translation => translation === undefined
         ? Reader.of(undefined)
-        : translateR("SR {$value}", { value: enhancement.content.skill_rating }).thenW(sr => translateR("{$value} AP", {
-            value: getEnhancementAPValue(enhancement.content.adventurePoints, parentImprovementCost),
+        : translateR("SR {$value}", { value: enhancement.content.skill_rating.toFixed() }).thenW(sr => translateR("{$value} AP", {
+            value: getEnhancementAPValue(enhancement.content.adventurePoints, parentImprovementCost).toFixed(),
         }).thenW(ap => (prerequisites === undefined
             ? Reader.of("")
             : translateR(".input {$hiddenCount :number} {{Prerequisites}}", {

package/lib/entities/partial/herbary.js

@@ -47,7 +47,7 @@ export const renderChance = (translate, translateMap, item, includePercentage =
     (item.chance === undefined
         ? undefined
         : translate("{$valueRange} on {$dice}", {
-            valueRange: item.chance === 5 ? 1 : `1–${(item.chance / 5).toFixed()}`,
+            valueRange: item.chance === 5 ? "1" : `1–${(item.chance / 5).toFixed()}`,
             dice: renderDice(translate, { number: 1, sides: 20 }),
         }) +
             (includePercentage

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

@@ -1,6 +1,7 @@
 import { Reader } from "@elyukai/utils/reader";
 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 type { StdEnv, StdReader } from "../../../env.js";
+import type { RawEntityDescriptionBadge } from "../../../index.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;
 /**
@@ -70,4 +71,8 @@ export declare const printGeodeRitualPrerequisites: (value: GeodeRitualPrerequis
  * Print enhancement prerequisites as a string.
  */
 export declare const printEnhancementPrerequisites: (value: EnhancementPrerequisites) => Reader<DeriveEnvF<typeof printEnhancementPrerequisiteGroup> & StdEnv<"lj" | "lc">, string>;
+/**
+ * Get the focus rule badge from prerequisites.
+ */
+export declare const getDerivedFocusRuleBadgeFromPrerequisites: (prerequisites: AdvantageDisadvantagePrerequisites | GeneralPrerequisites | PlainGeneralPrerequisites) => StdReader<RawEntityDescriptionBadge | undefined, "ibi", "FocusRule">;
 export {};

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

@@ -7,7 +7,7 @@ import { isNotNullish } from "@optolith/helpers/nullable";
 import { romanize } from "@optolith/helpers/roman";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { renderActivatableNameComponents, renderActivatableNameComponentsCombinedIfPossible, } from "../activatableNameChunks.js";
-import { localeJoinR, translateR } from "../reader.js";
+import { getInstanceByIdR, localeJoinR, translateR } from "../reader.js";
 import { MISSING_VALUE } from "../unknown.js";
 import { printDisplayOption } from "./displayOption.js";
 import { hasPartValueObject, joinPrerequisiteParts } from "./part.js";
@@ -230,3 +230,26 @@ export const printGeodeRitualPrerequisites = (value) => printPlainPrerequisites(
  * Print enhancement prerequisites as a string.
  */
 export const printEnhancementPrerequisites = (value) => printPlainPrerequisites(printEnhancementPrerequisiteGroup, value);
+const getDerivedFocusRuleBadgeFromPrerequisite = (prerequisite) => prerequisite.kind === "Single" &&
+    prerequisite.Single.kind === "Rule" &&
+    prerequisite.Single.Rule.id.kind === "FocusRule"
+    ? getInstanceByIdR(prerequisite.Single.Rule.id).map(focusRule => focusRule?.level)
+    : Reader.of(undefined);
+/**
+ * Get the focus rule badge from prerequisites.
+ */
+export const getDerivedFocusRuleBadgeFromPrerequisites = (prerequisites) => Reader.asks(env => {
+    for (const element of prerequisites) {
+        const actualPrerequisite = "level" in element ? (element.level === 1 ? element.prerequisite : undefined) : element;
+        if (actualPrerequisite !== undefined) {
+            const badge = getDerivedFocusRuleBadgeFromPrerequisite(actualPrerequisite).run(env);
+            if (badge !== undefined) {
+                return {
+                    type: "level",
+                    value: romanize(badge),
+                };
+            }
+        }
+    }
+    return undefined;
+});

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

@@ -12,7 +12,7 @@ export const printPersonalityTraitPrerequisite = (prerequisite) => prerequisite.
         : attributedNameFromInstanceR(personalityTrait, "prerequisite", "PersonalityTrait", prerequisite.id)
             .map(name => name ?? MISSING_VALUE)
             .thenW(name => translateR("Level {$level}", {
-            level: personalityTrait.level,
+            level: personalityTrait.level.toFixed(),
         }).map(level => `${name} (${level})`))
             .then(name => prerequisite.active
             ? translateR("must have {$trait}", {

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

@@ -13,7 +13,7 @@ export const printRatedSumPrerequisite = (prerequisite) => prerequisite.display_
         .thenW(skills => localeJoinR(skills, "conjunction"))
         .thenW(skills => translateR("the SR for {$skill} combined must add up to at least {$minRating}", {
         skill: skills,
-        minRating: prerequisite.sum,
+        minRating: prerequisite.sum.toFixed(),
     }))
         .map(value => ({
         value,

package/lib/entities/partial/profession/options/combatTechniquesForAdventurePoints.d.ts

@@ -0,0 +1,16 @@
+import type { NonEmptyArray } from "@elyukai/utils/array/nonEmpty";
+import { Reader } from "@elyukai/utils/reader";
+import type { CombatTechniquesForAdventurePointsOption, VariantOptionAction } from "@optolith/database-schema/gen";
+import type { StdEnv } from "../../../../env.js";
+import { type PreparedProfessionPackage } from "../packages.js";
+type Option = CombatTechniquesForAdventurePointsOption;
+type OptionEnv = StdEnv<"t" | "tm" | "ibi", "CloseCombatTechnique" | "RangedCombatTechnique">;
+/**
+ * Renders the combat techniques for adventure points option for a list of profession packages.
+ */
+export declare const renderBaseCombatTechniquesForAdventurePointsOption: (professionPackages: NonEmptyArray<PreparedProfessionPackage>) => Reader<OptionEnv, string | undefined>;
+/**
+ * Renders the combat techniques for adventure points option for a variant of a profession package.
+ */
+export declare const renderVariantCombatTechniquesForAdventurePointsOption: (baseOptions: Option | undefined, variantOptions: VariantOptionAction<Option>) => Reader<OptionEnv, string>;
+export {};

package/lib/entities/partial/profession/options/combatTechniquesForAdventurePoints.js

@@ -0,0 +1,43 @@
+import { deepEqual, equal } from "@elyukai/utils/equality";
+import { Reader } from "@elyukai/utils/reader";
+import { attributedNameR, fixedNumberOrString, translateR } from "../../reader.js";
+import { MISSING_VALUE } from "../../unknown.js";
+import { renderParameterizedOptionForBaseAndVariant, renderParameterizedOptionForMultiplePackages, } from "../packages.js";
+const renderCombatTechniquesForAdventurePointsOptionList = (options) => Reader.traverse(options, id => attributedNameR("profession", id).map(name => name ?? MISSING_VALUE)).map(list => list.join(", "));
+const renderCombatTechniquesForAdventurePointsOptionText = (apValue, list) => translateR("{$apValue} AP to distribute among the following combat techniques: {$list}", {
+    apValue: fixedNumberOrString(apValue),
+    list,
+});
+const renderStandaloneOption = (option) => renderCombatTechniquesForAdventurePointsOptionList(option.options).thenW(list => renderCombatTechniquesForAdventurePointsOptionText(option.apValue.toFixed(), list));
+const configs = [
+    {
+        selector: option => option.apValue,
+        equality: equal,
+        render: apValue => Reader.of(apValue),
+        renderAsString: apValue => Reader.of(apValue.toFixed()),
+        emptyText: "—",
+        joiner: "/",
+    },
+    {
+        selector: option => option.options,
+        equality: deepEqual,
+        render: renderCombatTechniquesForAdventurePointsOptionList,
+        renderAsString: renderCombatTechniquesForAdventurePointsOptionList,
+        emptyText: "—",
+        joiner: " / ",
+    },
+];
+const render = (apValue, list) => translateR("{$apValue} AP to distribute among the following combat techniques: {$list}", {
+    apValue: fixedNumberOrString(apValue),
+    list,
+});
+/**
+ * Renders the combat techniques for adventure points option for a list of profession packages.
+ */
+export const renderBaseCombatTechniquesForAdventurePointsOption = (professionPackages) => renderParameterizedOptionForMultiplePackages(professionPackages, pkg => pkg.content.options?.combatTechniquesForAdventurePoints, { type: "separate", emptyText: "—", joiner: " / " }, render, ...configs);
+/**
+ * Renders the combat techniques for adventure points option for a variant of a profession package.
+ */
+export const renderVariantCombatTechniquesForAdventurePointsOption = (baseOptions, variantOptions) => renderParameterizedOptionForBaseAndVariant(baseOptions, variantOptions, { type: "separate", emptyText: "—", joiner: " / " }, base => renderCombatTechniquesForAdventurePointsOptionList(base.options).thenW(list => translateR("no AP to distribute among the following combat techniques: {$list}", {
+    list,
+})), renderStandaloneOption, render, ...configs);

package/lib/entities/partial/profession/options/numberOfSpellworksTotalingAdventurePoints.d.ts

@@ -0,0 +1,16 @@
+import type { NonEmptyArray } from "@elyukai/utils/array/nonEmpty";
+import { Reader } from "@elyukai/utils/reader";
+import type { SpellworksOptions, VariantOptionAction } from "@optolith/database-schema/gen";
+import type { StdEnv } from "../../../../env.js";
+import { type PreparedProfessionPackage } from "../packages.js";
+type Option = SpellworksOptions;
+type OptionEnv = StdEnv<"t">;
+/**
+ * Renders the combat techniques for adventure points option for a list of profession packages.
+ */
+export declare const renderBaseNumberOfSpellworksTotalingAdventurePoints: (professionPackages: NonEmptyArray<PreparedProfessionPackage>) => Reader<OptionEnv, string | undefined>;
+/**
+ * Renders the combat techniques for adventure points option for a variant of a profession package.
+ */
+export declare const renderVariantNumberOfSpellworksTotalingAdventurePoints: (baseOptions: Option | undefined, variantOptions: VariantOptionAction<Option>) => Reader<OptionEnv, string>;
+export {};

package/lib/entities/partial/profession/options/numberOfSpellworksTotalingAdventurePoints.js

@@ -0,0 +1,39 @@
+import { equal } from "@elyukai/utils/equality";
+import { Reader } from "@elyukai/utils/reader";
+import { fixedNumberOrString, translateR } from "../../reader.js";
+import { renderParameterizedOptionForBaseAndVariant, renderParameterizedOptionForMultiplePackages, } from "../packages.js";
+const configs = [
+    {
+        selector: option => option.number,
+        equality: equal,
+        render: apValue => Reader.of(apValue),
+        renderAsString: apValue => Reader.of(apValue.toFixed()),
+        emptyText: "—",
+        joiner: "/",
+    },
+    {
+        selector: option => option.apValue,
+        equality: equal,
+        render: apValue => Reader.of(apValue),
+        renderAsString: apValue => Reader.of(apValue.toFixed()),
+        emptyText: "—",
+        joiner: "/",
+    },
+];
+const render = (count, apValue) => typeof count === "number"
+    ? translateR(".input {$count :number} {{{$count} more spellworks totaling {$apValue} AP}}", {
+        count,
+        apValue: fixedNumberOrString(apValue),
+    })
+    : translateR("{$count} more spellworks totaling {$apValue} AP", {
+        count,
+        apValue: fixedNumberOrString(apValue),
+    });
+/**
+ * Renders the combat techniques for adventure points option for a list of profession packages.
+ */
+export const renderBaseNumberOfSpellworksTotalingAdventurePoints = (professionPackages) => renderParameterizedOptionForMultiplePackages(professionPackages, pkg => pkg.content.options?.spellworks, { type: "separate", emptyText: "—", joiner: " / " }, render, ...configs);
+/**
+ * Renders the combat techniques for adventure points option for a variant of a profession package.
+ */
+export const renderVariantNumberOfSpellworksTotalingAdventurePoints = (baseOptions, variantOptions) => renderParameterizedOptionForBaseAndVariant(baseOptions, variantOptions, { type: "separate", emptyText: "—", joiner: " / " }, base => render(0, base.apValue), base => render(base.number, base.apValue), render, ...configs);