@optolith/entity-descriptions 0.4.11 → 0.4.13

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.4.13](https://github.com/Optolith/entity-descriptions/compare/v0.4.12...v0.4.13) (2026-06-01)
+
+
+### Bug Fixes
+
+* always display max SR for skill distributions ([248e706](https://github.com/Optolith/entity-descriptions/commit/248e7068b880eb820b60c2c36c0d8157abba1c7e))
+* hide variants term for multi-EL professions without variants ([25331f9](https://github.com/Optolith/entity-descriptions/commit/25331f9e9232081a4d4110e273b7096c4dfacdfd))
+* invalid markdown syntax for enhancement in profession ([0be5077](https://github.com/Optolith/entity-descriptions/commit/0be5077332a126061ca2618d5474d88e096594e4))
+
+## [0.4.12](https://github.com/Optolith/entity-descriptions/compare/v0.4.11...v0.4.12) (2026-05-31)
+
+
+### Features
+
+* add ap and fix minor issues to/with lesson packages ([cf4d0ec](https://github.com/Optolith/entity-descriptions/commit/cf4d0ec0cc615cbd5390919dff79cfe3c409d190))
+* adjust race for schema change and improve commonness rating display ([480f004](https://github.com/Optolith/entity-descriptions/commit/480f004e6e82995c2d651702521a289584360c76))
+* generate favored skills and primary attribute tradition rules ([9bee3c1](https://github.com/Optolith/entity-descriptions/commit/9bee3c1728d11f196f09bfd93afb03033564aa34))
+
+
+### Bug Fixes
+
+* add maximum skill rating appendix ([7be6362](https://github.com/Optolith/entity-descriptions/commit/7be63623b6bbf7fe3f307f17a41efd72b119fd1d))
+* equipment translation type mismatch ([a594c7c](https://github.com/Optolith/entity-descriptions/commit/a594c7cc5f44c7b52c3886dbce10ba37ed8d5f76))
+
 ## [0.4.11](https://github.com/Optolith/entity-descriptions/compare/v0.4.10...v0.4.11) (2026-03-23)
 
 

package/lib/creator.d.ts

@@ -1,4 +1,4 @@
-import type { EntityMap } from "optolith-database-schema/gen";
+import type { EntityMap } from "@optolith/database-schema/gen";
 import type { GetInstanceById } from "./helpers/getTypes.js";
 import type { LocaleEnvironment } from "./helpers/locale.js";
 import type { EntityDescription, RawEntityDescription } from "./index.js";

package/lib/entities/activatable.d.ts

@@ -1,4 +1,4 @@
-import type { ActivatableIdentifier, AdvancedSpecialAbility, AdvantageDisadvantagePrerequisites, AdventurePointsValue, ApplicableCombatTechniques, Aspect_ID, CombatSpecialAbilityUsageType, DaggerRitualCost, EnchantmentCost, Errata, GeneralPrerequisites, MagicalSignCost, Penalty, PropertyDeclaration, PublicationRefs, RatedIdentifier, SelectOptions, SpecialRule, Volume } from "optolith-database-schema/gen";
+import type { ActivatableIdentifier, AdvancedSpecialAbility, AdvantageDisadvantagePrerequisites, AdventurePointsValue, ApplicableCombatTechniques, Aspect_ID, CombatSpecialAbilityUsageType, DaggerRitualCost, EnchantmentCost, Errata, GeneralPrerequisites, MagicalSignCost, Penalty, PropertyDeclaration, PublicationRefs, RatedIdentifier, SelectOptions, SpecialRule, Volume } from "@optolith/database-schema/gen";
 import { Case } from "tsondb/schema/gen";
 import type { GetAllInstances, GetInstanceById } from "../helpers/getTypes.js";
 import type { GetAllResolvedNewSkillApplications, GetAllResolvedSelectOptions, GetAllResolvedSkillUses } from "../index.js";

package/lib/entities/activatable.js

@@ -3,6 +3,7 @@ import { count } from "@elyukai/utils/array/reductions";
 import { deepEqual } from "@elyukai/utils/equality";
 import { on } from "@elyukai/utils/function";
 import { isNotNullish } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
 import { numAsc } from "@optolith/helpers/compare";
 import { sign } from "@optolith/helpers/math";
 import { mapNullable, mapNullableDefault } from "@optolith/helpers/nullable";
@@ -18,6 +19,7 @@ import { additionFormatter } from "./partial/mathOperation.js";
 import { printAdvantageDisadvantagePrerequisites, printGeneralPrerequisites, } from "./partial/prerequisites/index.js";
 import { printActivatableName, } from "./partial/prerequisites/single/activatable.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
+import { attributedNameR, localeSortR, translateR, } from "./partial/reader.js";
 import { getResponsiveText, getResponsiveTextOptional, ResponsiveTextSize, } from "./partial/responsiveText.js";
 import { formatTimeSpan } from "./partial/units/timeSpan.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
@@ -626,6 +628,60 @@ const renderTrailingAdvancedPrerequisitesNote = (translate, entityName) => {
     }
     return undefined;
 };
+const renderFavoredCombatTechniques = (favoredCombatTechniques) => {
+    if (favoredCombatTechniques === undefined) {
+        return Reader.of([]);
+    }
+    switch (favoredCombatTechniques.kind) {
+        case "All":
+            return translateR("All Combat Techniques").map(text => [text]);
+        case "AllClose":
+            return translateR("All Close Combat Techniques").map(text => [text]);
+        case "AllUsedInHunting":
+            return translateR("All Combat Techniques used in hunting").map(text => [text]);
+        case "Specific":
+            return Reader.traverse(favoredCombatTechniques.Specific.list, id => attributedNameR("favored-skills", id)
+                .map(name => name ?? MISSING_VALUE)
+                .thenW(name => translateR("Combat Technique {$name}", { name }))).thenW(localeSortR);
+        default:
+            return assertExhaustive(favoredCombatTechniques);
+    }
+};
+const renderFavoredSkillsBaseList = (combatTechniques, favoredSkills) => Reader.traverse(favoredSkills, id => attributedNameR("favored-skills", "Skill", id).map(name => name ?? MISSING_VALUE))
+    .thenW(localeSortR)
+    .map(favoredSkillNames => combatTechniques.concat(favoredSkillNames).join(", "));
+const renderFavoredSkillsSelection = (baseList, favoredSkillsSelection) => favoredSkillsSelection === undefined
+    ? Reader.of(baseList)
+    : Reader.traverse(favoredSkillsSelection.options, id => attributedNameR("favored-skills", "Skill", id)).thenW(names => translateR(".input {$count :number} {{{$baseList}, and {$count} of your choice from the following list: {$selection}}}", {
+        count: favoredSkillsSelection.number,
+        baseList,
+        selection: names.join(", "),
+    }));
+const renderFavoredSkillsSpecialRule = (favoredCombatTechniques, favoredSkills, favoredSkillsSelection) => translateR("Favored Skills").thenW(label => renderFavoredCombatTechniques(favoredCombatTechniques)
+    .thenW(favoredCombatTechniquesText => renderFavoredSkillsBaseList(favoredCombatTechniquesText, favoredSkills))
+    .thenW(list => renderFavoredSkillsSelection(list, favoredSkillsSelection))
+    .map(text => ({
+    label,
+    text,
+})));
+const renderPrimaryAttributeSpecialRule = (traditionName, nameOfPeopleWithThisTradition, primaryAttribute) => (primaryAttribute === undefined
+    ? translateR("Tradition ({$name}) has no associated primary attribute, meaning {$casters} receive no bonus to the AE pool and cannot purchase additional AE.", { name: traditionName, casters: nameOfPeopleWithThisTradition })
+    : attributedNameR("rules", "Attribute", typeof primaryAttribute === "string" ? primaryAttribute : primaryAttribute.id).thenW(attr => typeof primaryAttribute !== "string" && primaryAttribute.use_half_for_arcane_energy
+        ? translateR("This primary attribute of this Tradition is {$attr}; however, {$casters} use only half of this stat (rounded up) to calculate their base AE pool or purchase AE.", {
+            casters: nameOfPeopleWithThisTradition,
+            attr: attr ?? MISSING_VALUE,
+        })
+        : translateR("The primary attribute of this Tradition is {$attr}.", {
+            attr: attr ?? MISSING_VALUE,
+        }))).map(description => ({
+    text: description,
+}));
+const renderAdditionalSpecialRules = (traditionName, nameOfPeopleWithThisTradition, favoredCombatTechniques, favoredSkills, favoredSkillsSelection, primaryAttribute) => Reader.sequence([
+    favoredSkills === undefined
+        ? Reader.of(undefined)
+        : renderFavoredSkillsSpecialRule(favoredCombatTechniques, favoredSkills, favoredSkillsSelection),
+    renderPrimaryAttributeSpecialRule(traditionName, nameOfPeopleWithThisTradition, primaryAttribute),
+]).map(specialRules => specialRules.filter(isNotNullish));
 /**
  * Get a JSON representation of the rules text for a special ability.
  */
@@ -636,8 +692,19 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
     if (translation === undefined) {
         return undefined;
     }
+    const env = {
+        translate,
+        translateMap,
+        getInstanceById,
+        localeCompare: locale.compare,
+    };
     const baseEntry = entry;
     const wrappedId = Case(entityName, id);
+    const additionalSpecialRules = entityName === "BlessedTradition"
+        ? renderAdditionalSpecialRules(translation.name, translation.nameOfBlessedOnes, entry.favored_combat_techniques, entry.favored_skills, entry.favored_skills_selection, entry.primary).run(env)
+        : entityName === "MagicalTradition"
+            ? renderAdditionalSpecialRules(translation.name, translation.nameOfSpellcasters, undefined, undefined, undefined, entry.primary).run(env)
+            : [];
     return {
         title: (translation.name_in_library ?? translation.name) +
             (baseEntry.levels !== undefined ? ` I–${romanize(baseEntry.levels)}` : ""),
@@ -658,6 +725,7 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
             mapNullable(translation.special_rules, specialRules => ({
                 type: "plain",
                 text: specialRules
+                    .concat(additionalSpecialRules)
                     .map(specialRule => specialRule.label === undefined
                     ? `- ${specialRule.text}`
                     : `- *${specialRule.label}*: ${specialRule.text}`)

package/lib/entities/culture.d.ts

@@ -1,8 +1,10 @@
 import type { GetAllChildInstancesForParent, GetInstanceById } from "../helpers/getTypes.js";
+import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";
 /**
  * Get a JSON representation of the rules text for a culture.
  */
 export declare const getCultureEntityDescription: import("../creator.js").EntityDescriptionCreator<"Culture", {
     getInstanceById: GetInstanceById<"Publication" | "Advantage" | "Disadvantage" | "Skill" | "Language" | "LanguageSpecialization" | "Script" | "SocialStatus" | "ProfessionVariant" | "MagicalTradition" | "BlessedTradition">;
     getChildInstancesForInstanceId: GetAllChildInstancesForParent<"ProfessionVersion">;
+    getResolvedSelectOptionById: GetResolvedSelectOptionById;
 }, import("../index.js").EntityDescription>;

package/lib/entities/culture.js

@@ -10,10 +10,18 @@ import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { getAdventurePointsForRatingRange } from "@optolith/adventure-points/improvement-cost";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
+import { attributedCustomName, attributedName, attributedNameFromSafeTranslation, } from "./partial/markdown.js";
 import { getProfessionName } from "./partial/professions.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
 import { translateR } from "./partial/reader.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
+const getAttributedProfessionName = (translateMap, getChildInstancesForInstanceId, professionId, context) => {
+    const baseName = getProfessionName(translateMap, getChildInstancesForInstanceId, professionId);
+    if (baseName === undefined) {
+        return undefined;
+    }
+    return attributedNameFromSafeTranslation({ name: baseName }, context, "Profession", professionId);
+};
 const renderListOperation = (operation, list) => {
     switch (operation.kind) {
         case "Intersection":
@@ -69,26 +77,23 @@ const renderWeighted = (weightedVariants, getName) => {
         }
     });
 };
-const renderProfessionConstraint = (getChildInstancesForInstanceId, constraint) => Reader.asks(({ translateMap }) => getProfessionName(translateMap, getChildInstancesForInstanceId, constraint.id)).thenW(baseName => baseName === undefined
+const renderProfessionConstraint = (getChildInstancesForInstanceId, constraint) => Reader.asks(({ translateMap }) => getAttributedProfessionName(translateMap, getChildInstancesForInstanceId, constraint.id, "common-professions")).thenW(baseName => baseName === undefined
     ? Reader.of(undefined)
     : Reader.sequence([
         renderRarity(constraint.rarity),
         Reader.asks(({ translateMap, getInstanceById }) => renderWeighted(constraint.weighted_variants, variantId => translateMap(getInstanceById("ProfessionVariant", variantId)?.translations)
             ?.name.default)).thenW(identity),
     ]).map(notes => baseName + parensIf(ensureNonEmpty(notes.filter(isNotNullish))?.join("; "))));
-const renderTraditionConstraint = (getChildInstancesForInstanceId, entity, constraint) => Reader.asks(({ translateMap, getInstanceById }) => {
-    const translation = translateMap(getInstanceById(entity, constraint.id)?.translations);
-    return translation?.nameOfBlessedOnes ?? translation?.name;
-}).thenW(baseName => baseName === undefined
+const renderTraditionConstraint = (getChildInstancesForInstanceId, entity, constraint) => Reader.asks(({ translateMap, getInstanceById }) => attributedCustomName(translateMap, getInstanceById, "common-professions", (translation) => translation.nameOfBlessedOnes ?? translation.name, entity, constraint.id)).thenW(baseName => baseName === undefined
     ? Reader.of(undefined)
     : Reader.sequence([
         renderRarity(constraint.rarity),
-        Reader.asks(({ translateMap }) => renderWeighted(constraint.weighted_professions, profId => getProfessionName(translateMap, getChildInstancesForInstanceId, profId))).thenW(identity),
+        Reader.asks(({ translateMap }) => renderWeighted(constraint.weighted_professions, profId => getAttributedProfessionName(translateMap, getChildInstancesForInstanceId, profId, "common-professions"))).thenW(identity),
     ]).map(notes => baseName + parensIf(ensureNonEmpty(notes.filter(isNotNullish))?.join("; "))));
 const renderCommonProfessions = (getChildInstancesForInstanceId, commonProfessions) => {
     switch (commonProfessions.kind) {
         case "Plain":
-            return renderCommonProfessionConstraints(commonProfessions.Plain, profId => Reader.asks(({ translateMap }) => getProfessionName(translateMap, getChildInstancesForInstanceId, profId)));
+            return renderCommonProfessionConstraints(commonProfessions.Plain, profId => Reader.asks(({ translateMap }) => getAttributedProfessionName(translateMap, getChildInstancesForInstanceId, profId, "common-professions")));
         case "Grouped":
             return renderCommonProfessionGroup("Mundane Professions", commonProfessions.Grouped.mundane, constraint => 
             // switch (constraint.kind) {
@@ -118,7 +123,7 @@ const renderCommonProfessions = (getChildInstancesForInstanceId, commonProfessio
 const renderCommonSkills = (items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
     ? translate("none")
     : items
-        .map(itemId => translateMap(getInstanceById("Skill", itemId)?.translations)?.name)
+        .map(itemId => attributedName(translateMap, getInstanceById, "common-skills", "Skill", itemId))
         .filter(isNotNullish)
         .toSorted(localeCompare)
         .join(", "));
@@ -157,7 +162,7 @@ const renderCulturalPackage = (items) => Reader.asks(({ translate, translateMap,
             return [MISSING_VALUE, 0];
         }
         return [
-            `${instanceTranslation.name} ${sign(item.points)}`,
+            `${attributedNameFromSafeTranslation(instanceTranslation, "cultural-package", "Skill", item.id)} ${sign(item.points)}`,
             getAdventurePointsForRatingRange(instance.improvement_cost.kind, 0, item.points),
         ];
     });
@@ -172,7 +177,7 @@ const renderCulturalPackage = (items) => Reader.asks(({ translate, translateMap,
 /**
  * Get a JSON representation of the rules text for a culture.
  */
-export const getCultureEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getChildInstancesForInstanceId }, { translate, translateMap, compare: localeCompare, join: localeJoin }, { content: entry }) => {
+export const getCultureEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getChildInstancesForInstanceId, getResolvedSelectOptionById }, { translate, translateMap, compare: localeCompare, join: localeJoin }, { content: entry }) => {
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
@@ -182,6 +187,7 @@ export const getCultureEntityDescription = createEntityDescriptionCreator(({ get
         translateMap,
         localeCompare,
         getInstanceById,
+        getResolvedSelectOptionById,
     };
     const { text: culturePackageText, apValue: culturalPackageApValue } = renderCulturalPackage(entry.cultural_package).run(env);
     return {
@@ -266,10 +272,10 @@ export const getCultureEntityDescription = createEntityDescriptionCreator(({ get
                         label: translate("Common Professions"),
                         value: renderCommonProfessions(getChildInstancesForInstanceId, entry.common_professions).run(env),
                     },
-                    renderValueWithPossibleTranslation("Common Advantages", entry.common_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values).run(env), translation.common_advantages).run(env),
-                    renderValueWithPossibleTranslation("Common Disadvantages", entry.common_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values).run(env), translation.common_disadvantages).run(env),
-                    renderValueWithPossibleTranslation("Uncommon Advantages", entry.uncommon_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values).run(env), translation.uncommon_advantages).run(env),
-                    renderValueWithPossibleTranslation("Uncommon Disadvantages", entry.uncommon_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values).run(env), translation.uncommon_disadvantages).run(env),
+                    renderValueWithPossibleTranslation("Common Advantages", entry.common_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values, translate("none")).run(env), translation.common_advantages).run(env),
+                    renderValueWithPossibleTranslation("Common Disadvantages", entry.common_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values, translate("none")).run(env), translation.common_disadvantages).run(env),
+                    renderValueWithPossibleTranslation("Uncommon Advantages", entry.uncommon_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values, translate("none")).run(env), translation.uncommon_advantages).run(env),
+                    renderValueWithPossibleTranslation("Uncommon Disadvantages", entry.uncommon_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values, translate("none")).run(env), translation.uncommon_disadvantages).run(env),
                     {
                         label: translate("Common Skills"),
                         value: renderCommonSkills(entry.common_skills).run(env),

package/lib/entities/curriculum.js

@@ -1,8 +1,12 @@
 import { partition } from "@elyukai/utils/array/groups";
+import { ensureNonEmpty } from "@elyukai/utils/array/nonEmpty";
+import { sumWith } from "@elyukai/utils/array/reductions";
 import { Dictionary } from "@elyukai/utils/dictionary";
 import { deepEqual } from "@elyukai/utils/equality";
+import { on } from "@elyukai/utils/function";
 import { sign } from "@elyukai/utils/string/number";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { getAdventurePointsForActivation, getAdventurePointsForRatingRange, } from "@optolith/adventure-points/improvement-cost";
 import { isNotNullish, mapNullable } from "@optolith/helpers/nullable";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { attributedName } from "./partial/markdown.js";
@@ -43,7 +47,8 @@ const renderRestrictedSpellworks = (translate, translateMap, localeCompare, loca
         }
         const translatedSpellworks = excludedSpellworks
             .map(excludedSpellwork => attributedName(translateMap, getInstanceById, "curriculum", excludedSpellwork))
-            .filter(isNotNullish);
+            .filter(isNotNullish)
+            .toSorted(localeCompare);
         if (translatedSpellworks.length === 0) {
             return "";
         }
@@ -60,7 +65,7 @@ const renderRestrictedSpellworks = (translate, translateMap, localeCompare, loca
         ?.map(restriction => {
         switch (restriction.kind) {
             case "Property":
-                return attributedName(translateMap, getInstanceById, "curriculum", "Property", restriction.Property.id);
+                return ((attributedName(translateMap, getInstanceById, "curriculum", "Property", restriction.Property.id) ?? MISSING_VALUE) + addExclusion(restriction.Property.exclude));
             case "DemonSummoning":
                 return translate("Demon Summoning");
             default:
@@ -101,9 +106,9 @@ const renderRestrictedSpellworks = (translate, translateMap, localeCompare, loca
     }) ?? [];
     return [...restrictedProperties, ...properties, ...others, ...spellworks].join("; ");
 };
-const renderSpellworkAdjustment = (translateMap, getInstanceById, adjustment) => `${attributedName(translateMap, getInstanceById, "curriculum", adjustment.id) ?? MISSING_VALUE} ${adjustment.points.toFixed()}${parensIf(adjustment.tradition === undefined
+const renderSpellworkAdjustment = (translateMap, getInstanceById, adjustment) => `${attributedName(translateMap, getInstanceById, "curriculum", adjustment.id) ?? MISSING_VALUE}${parensIf(adjustment.tradition === undefined
     ? undefined
-    : attributedName(translateMap, getInstanceById, "curriculum", "MagicalTradition", adjustment.tradition))}`;
+    : attributedName(translateMap, getInstanceById, "curriculum", "MagicalTradition", adjustment.tradition))} ${typeof adjustment.points === "number" ? adjustment.points.toFixed() : adjustment.points}`;
 const renderAbilityAdjustmentName = (translateMap, getInstanceById, abilityAdjustment) => {
     switch (abilityAdjustment.kind) {
         case "Skill":
@@ -133,6 +138,18 @@ const renderAbilityAdjustmentBaseValue = (baseProfessionPackage, abilityAdjustme
             return assertExhaustive(abilityAdjustment);
     }
 };
+const renderPrintedAbilityAdjustmentBaseValue = (abilityAdjustment) => {
+    switch (abilityAdjustment.kind) {
+        case "Skill":
+            return abilityAdjustment.Skill.basePoints;
+        case "CombatTechnique":
+            return abilityAdjustment.CombatTechnique.basePoints;
+        case "Spellwork":
+            return abilityAdjustment.Spellwork.basePoints;
+        default:
+            return assertExhaustive(abilityAdjustment);
+    }
+};
 const renderAbilityAdjustmentModifierValue = (abilityAdjustment) => {
     switch (abilityAdjustment.kind) {
         case "Skill":
@@ -160,17 +177,58 @@ const renderAbilityAdjustmentDefaultValue = (abilityAdjustment) => {
 const renderAbilityAdjustment = (translate, translateMap, getInstanceById, baseProfessionPackage) => baseProfessionPackage === undefined
     ? abilityAdjustment => `${renderAbilityAdjustmentName(translateMap, getInstanceById, abilityAdjustment)} ${sign(renderAbilityAdjustmentModifierValue(abilityAdjustment))}`
     : abilityAdjustment => {
+        const defaultValue = renderAbilityAdjustmentDefaultValue(abilityAdjustment);
         const basePoints = (renderAbilityAdjustmentBaseValue(baseProfessionPackage, abilityAdjustment) ?? 0) +
-            renderAbilityAdjustmentDefaultValue(abilityAdjustment);
+            defaultValue;
+        const printedBaseValue = mapNullable(renderPrintedAbilityAdjustmentBaseValue(abilityAdjustment), value => value + defaultValue);
         return translate("{$replacement} instead of {$base}", {
-            base: basePoints,
+            base: printedBaseValue === basePoints
+                ? basePoints
+                : `<ins>${basePoints.toFixed()}</ins><del>${printedBaseValue?.toFixed() ?? "n/a"}</del>`,
             replacement: `${renderAbilityAdjustmentName(translateMap, getInstanceById, abilityAdjustment)} ${(basePoints + renderAbilityAdjustmentModifierValue(abilityAdjustment)).toFixed()}`,
         });
     };
-const renderAbilityAdjustments = (translate, translateMap, localeCompare, getInstanceById, baseProfessionPackage, list) => list
+const renderAbilityAdjustments = (translate, translateMap, localeCompare, getInstanceById, baseProfessionPackage, list) => ensureNonEmpty(list
     .map(renderAbilityAdjustment(translate, translateMap, getInstanceById, baseProfessionPackage))
-    .toSorted(localeCompare)
-    .join(", ");
+    .toSorted(localeCompare))?.join(", ") ?? "—";
+const calculateApForSpellworkAdjustment = (getInstanceById, adjustment, includeActivation = false) => {
+    const instance = getInstanceById(adjustment.id);
+    if (instance === undefined) {
+        return 0;
+    }
+    return ((getAdventurePointsForRatingRange(instance.improvement_cost.kind, 0, Math.abs(adjustment.points)) +
+        (includeActivation ? getAdventurePointsForActivation(instance.improvement_cost.kind) : 0)) *
+        (adjustment.points > 0 ? 1 : -1));
+};
+const calculateApForSpellworkChanges = (getInstanceById, spellworkChanges) => sumWith(spellworkChanges ?? [], change => calculateApForSpellworkAdjustment(getInstanceById, change.replacement, true) -
+    calculateApForSpellworkAdjustment(getInstanceById, change.base, true));
+const calculateApForAbilityAdjustments = (getInstanceById, baseProfessionPackage, abilityAdjustments) => sumWith(abilityAdjustments, adjustment => {
+    switch (adjustment.kind) {
+        case "CombatTechnique": {
+            const instance = getInstanceById(adjustment.CombatTechnique.id);
+            if (instance === undefined) {
+                return 0;
+            }
+            return (getAdventurePointsForRatingRange(instance.improvement_cost.kind, 0, Math.abs(adjustment.CombatTechnique.points)) * (adjustment.CombatTechnique.points > 0 ? 1 : -1));
+        }
+        case "Skill": {
+            const instance = getInstanceById("Skill", adjustment.Skill.id);
+            if (instance === undefined) {
+                return 0;
+            }
+            return (getAdventurePointsForRatingRange(instance.improvement_cost.kind, 0, Math.abs(adjustment.Skill.points)) * (adjustment.Skill.points > 0 ? 1 : -1));
+        }
+        case "Spellwork": {
+            const baseValue = baseProfessionPackage &&
+                renderAbilityAdjustmentBaseValue(baseProfessionPackage, adjustment);
+            const includeActivation = baseValue === undefined ||
+                baseValue + renderAbilityAdjustmentDefaultValue(adjustment) === 0;
+            return calculateApForSpellworkAdjustment(getInstanceById, adjustment.Spellwork, includeActivation);
+        }
+        default:
+            return assertExhaustive(adjustment);
+    }
+});
 /**
  * Get a JSON representation of the rules text for a curriculum.
  */
@@ -219,36 +277,62 @@ export const getCurriculumEntityDescription = createEntityDescriptionCreator(({
                             return assertExhaustive(adjustment);
                     }
                 });
+                const apValueBase = baseProfessionPackage?.ap_value;
+                const apValueForSpellworkChanges = calculateApForSpellworkChanges(getInstanceById, lessonPackage.content.spellwork_changes);
+                const apValueForBoni = calculateApForAbilityAdjustments(getInstanceById, baseProfessionPackage, boni);
+                const apValueForMali = calculateApForAbilityAdjustments(getInstanceById, baseProfessionPackage, mali);
+                const totalApValue = (apValueBase ?? 0) + apValueForSpellworkChanges + apValueForBoni + apValueForMali;
+                const derivedApValueText = `^[${totalApValue.toFixed()}](base: ${baseProfessionPackage?.ap_value.toFixed() ?? '"n/a"'}, changes: ${calculateApForSpellworkChanges(getInstanceById, lessonPackage.content.spellwork_changes).toFixed()}, boni: ${calculateApForAbilityAdjustments(getInstanceById, baseProfessionPackage, boni).toFixed()}, mali: ${calculateApForAbilityAdjustments(getInstanceById, baseProfessionPackage, mali).toFixed()})`;
                 return {
                     type: "labeled",
-                    label: lessonPackageTranslation.name,
+                    label: lessonPackageTranslation.name +
+                        parensIf(translate("{$value} AP", {
+                            value: lessonPackage.content.apValue === totalApValue
+                                ? derivedApValueText
+                                : `<ins>${derivedApValueText}</ins><del>${lessonPackage.content.apValue?.toFixed() ?? "n/a"}</del>`,
+                        })),
                     value: {
                         type: "definitionList",
                         items: [
                             {
                                 label: translate("Spellwork Changes"),
                                 value: lessonPackageTranslation.spellwork_changes ??
-                                    lessonPackage.content.spellwork_changes
-                                        ?.map(change => translate("{$replacement} instead of {$base}", {
-                                        base: renderSpellworkAdjustment(translateMap, getInstanceById, change.base),
-                                        replacement: renderSpellworkAdjustment(translateMap, getInstanceById, change.replacement),
-                                    }))
-                                        .join(", ") ??
+                                    ensureNonEmpty((lessonPackage.content.spellwork_changes?.map(change => {
+                                        const baseValueFromProfession = baseProfessionPackage
+                                            ? renderAbilityAdjustmentBaseValue(baseProfessionPackage, {
+                                                kind: "Spellwork",
+                                                Spellwork: change.base,
+                                            })
+                                            : undefined;
+                                        return translate("{$replacement} instead of {$base}", {
+                                            base: renderSpellworkAdjustment(translateMap, getInstanceById, {
+                                                ...change.base,
+                                                points: baseValueFromProfession === change.base.points
+                                                    ? change.base.points
+                                                    : `<ins>${baseValueFromProfession?.toFixed() ?? "n/a"}</ins><del>${change.base.points.toFixed()}</del>`,
+                                            }),
+                                            replacement: renderSpellworkAdjustment(translateMap, getInstanceById, change.replacement),
+                                        });
+                                    }) ?? []).concat(lessonPackage.content.skills
+                                        ?.filter(abilityAdjustment => abilityAdjustment.kind === "Spellwork")
+                                        .map(renderAbilityAdjustment(translate, translateMap, getInstanceById, baseProfessionPackage))
+                                        .toSorted(localeCompare) ?? []))?.join(", ") ??
                                     translate("none"),
                             },
                             {
                                 label: translate("Skills (+)"),
-                                value: renderAbilityAdjustments(translate, translateMap, localeCompare, getInstanceById, baseProfessionPackage, boni),
+                                value: renderAbilityAdjustments(translate, translateMap, localeCompare, getInstanceById, baseProfessionPackage, boni.filter(abilityAdjustment => abilityAdjustment.kind !== "Spellwork")),
                             },
                             {
                                 label: translate("Skills (−)"),
-                                value: renderAbilityAdjustments(translate, translateMap, localeCompare, getInstanceById, baseProfessionPackage, mali),
+                                value: renderAbilityAdjustments(translate, translateMap, localeCompare, getInstanceById, baseProfessionPackage, mali.filter(abilityAdjustment => abilityAdjustment.kind !== "Spellwork")),
                             },
                         ],
                     },
                 };
             }))
-                .filter(isNotNullish),
+                .filter(isNotNullish)
+                .toSorted(on(packageDescription => packageDescription.label, localeCompare)),
         ],
         errata: translation.errata,
         references: entry.src,

package/lib/entities/disease.d.ts

@@ -3,7 +3,7 @@ import type { IdMap } from "../index.js";
 /**
  * Get a JSON representation of the rules text for an optional rule.
  */
-export declare const getDiseaseEntityDescription: import("../creator.js").EntityDescriptionCreator<"AnimalDisease" | "Disease", {
+export declare const getDiseaseEntityDescription: import("../creator.js").EntityDescriptionCreator<"Disease" | "AnimalDisease", {
     getInstanceById: GetInstanceById<"Publication" | "AnimalType" | "DerivedCharacteristic">;
     idMap: IdMap;
 }, import("../index.js").EntityDescription>;

package/lib/entities/elixir.d.ts

@@ -1,4 +1,4 @@
-import type { ActivatableIdentifier, RatedIdentifier } from "optolith-database-schema/gen";
+import type { ActivatableIdentifier, RatedIdentifier } from "@optolith/database-schema/gen";
 import type { GetInstanceById } from "../helpers/getTypes.js";
 import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";
 /**

package/lib/entities/equipment.d.ts

@@ -1,4 +1,4 @@
-import type { AmmunitionishIdentifier, EquipmentIdentifier, GenMeleeWeapon, GenRangedWeapon, LocaleMeasurementAdjustments } from "optolith-database-schema/gen";
+import type { AmmunitionishIdentifier, EquipmentIdentifier, GenMeleeWeapon, GenRangedWeapon, LocaleMeasurementAdjustments } from "@optolith/database-schema/gen";
 import { type TaggedEntity } from "../creator.js";
 import type { GetInstanceById } from "../helpers/getTypes.js";
 import type { LocaleJoin } from "../helpers/locale.js";
@@ -19,7 +19,7 @@ export declare const renderRangedWeapon: <Damage>(translate: Translate, translat
 /**
  * Get a JSON representation of the rules text for equipment.
  */
-export declare const getEquipmentEntityDescription: import("../creator.js").EntityDescriptionCreator<"Ammunition" | "Weapon" | "Armor" | "Animal" | "AnimalCare" | "BandageOrRemedy" | "Book" | "CeremonialItem" | "Clothes" | "ClothingPackage" | "Container" | "EquipmentOfBlessedOnes" | "GemOrPreciousStone" | "IlluminationLightSource" | "IlluminationRefillOrSupply" | "Jewelry" | "Laboratory" | "Liebesspielzeug" | "LuxuryGood" | "MagicalArtifact" | "MusicalInstrument" | "Newspaper" | "OrienteeringAid" | "RopeOrChain" | "Stationery" | "ThievesTool" | "ToolOfTheTrade" | "TravelGearOrTool" | "Vehicle" | "WeaponAccessory" | "WorkingSupernaturalCreature", {
+export declare const getEquipmentEntityDescription: import("../creator.js").EntityDescriptionCreator<"Weapon" | "Ammunition" | "Armor" | "Animal" | "AnimalCare" | "BandageOrRemedy" | "Book" | "CeremonialItem" | "Clothes" | "ClothingPackage" | "Container" | "EquipmentOfBlessedOnes" | "GemOrPreciousStone" | "IlluminationLightSource" | "IlluminationRefillOrSupply" | "Jewelry" | "Laboratory" | "Liebesspielzeug" | "LuxuryGood" | "MagicalArtifact" | "MusicalInstrument" | "Newspaper" | "OrienteeringAid" | "RopeOrChain" | "Stationery" | "ThievesTool" | "ToolOfTheTrade" | "TravelGearOrTool" | "Vehicle" | "WeaponAccessory" | "WorkingSupernaturalCreature", {
     getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Reach" | "SocialStatus" | "CloseCombatTechnique" | "RangedCombatTechnique" | "MagicalTradition" | "BlessedTradition" | "DerivedCharacteristic" | AmmunitionishIdentifier["kind"] | "Race" | "Culture" | "Profession" | "Skill">;
     idMap: IdMap;
 }, import("../index.js").EntityDescription>;

package/lib/entities/equipmentPackage.d.ts

@@ -1,4 +1,4 @@
-import type { EquipmentIdentifier } from "optolith-database-schema/gen";
+import type { EquipmentIdentifier } from "@optolith/database-schema/gen";
 import type { GetInstanceById } from "../helpers/getTypes.js";
 /**
  * Get a JSON representation of the rules text for an equipment package.

package/lib/entities/influence.d.ts

@@ -1,4 +1,4 @@
-import type { ActivatableIdentifier } from "optolith-database-schema/gen";
+import type { ActivatableIdentifier } from "@optolith/database-schema/gen";
 import type { GetAllChildInstancesForParent, GetInstanceById } from "../helpers/getTypes.js";
 import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";
 /**

package/lib/entities/liturgicalChant.d.ts

@@ -1,4 +1,4 @@
-import { type RatedIdentifier } from "optolith-database-schema/gen";
+import { type RatedIdentifier } from "@optolith/database-schema/gen";
 import type { GetAllChildInstancesForParent, GetInstanceById } from "../helpers/getTypes.js";
 import type { IdMap } from "../index.js";
 /**

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

@@ -1,4 +1,4 @@
-import type { ActivatableIdentifier, ActivatableNameBuilderRules, RequirableSelectOptionIdentifier } from "optolith-database-schema/gen";
+import type { ActivatableIdentifier, ActivatableNameBuilderRules, RequirableSelectOptionIdentifier } from "@optolith/database-schema/gen";
 import type { LocaleMap, Translate, TranslateMap } from "../../helpers/translate.js";
 import type { GetResolvedSelectOptionById } from "./prerequisites/single/activatable.js";
 /**
@@ -8,7 +8,7 @@ export type ActivatableNameComponents = {
     id: ActivatableIdentifier;
     base: ActivatableNameChunk;
     options: ActivatableNameChunk | [ActivatableNameChunk, ActivatableNameChunk] | undefined;
-    level: number | undefined;
+    level: number | [start: number, end: number] | undefined;
     nameBuilderRules: Required<ActivatableNameBuilderRules>;
 };
 /**
@@ -18,7 +18,7 @@ export type CombinedActivatableNameComponents = {
     id: ActivatableIdentifier;
     base: ActivatableNameChunk;
     options: (ActivatableNameChunk | [ActivatableNameChunk, ActivatableNameChunk])[];
-    level: number | undefined;
+    level: number | [start: number, end: number] | undefined;
     nameBuilderRules: Required<ActivatableNameBuilderRules>;
 };
 /**
@@ -52,6 +52,14 @@ export declare const renderMultipleStandaloneActivatableNameComponents: (transla
  * Renders the name components of multiple activatable entries, combining parts if possible.
  */
 export declare const renderActivatableNameComponentsCombinedIfPossible: (translateMap: TranslateMap, components: ActivatableNameComponents[], formatAsPrerequisite: boolean, join?: (list: string[]) => string) => string;
+/**
+ * Renders the options of an activatable entry, combining them if necessary.
+ */
+export declare const renderNameComponentsOptions: (displayedInProfession: boolean, getResolvedSelectOptionById: GetResolvedSelectOptionById, id: ActivatableIdentifier, options: RequirableSelectOptionIdentifier[] | undefined) => ActivatableNameChunk | [ActivatableNameChunk, ActivatableNameChunk] | undefined;
+/**
+ * Provides default values for name builder rules and ensures that all properties are present.
+ */
+export declare const makeNameBuilderRulesWithDefaults: (input: ActivatableNameBuilderRules | undefined) => Required<ActivatableNameBuilderRules>;
 /**
  * Gets the name components for an activatable entry.
  */