@optolith/entity-descriptions 0.4.13 → 0.4.15

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.4.15](https://github.com/Optolith/entity-descriptions/compare/v0.4.14...v0.4.15) (2026-06-07)
+
+
+### Bug Fixes
+
+* add sustained cost map interval ([f7c1b31](https://github.com/Optolith/entity-descriptions/commit/f7c1b31452befa0c898a6f21e4624c8084ea5df5))
+* display full tradition name ([2d07eff](https://github.com/Optolith/entity-descriptions/commit/2d07eff1d4b6a5b72ce705e24969e4a384a1d486))
+* ignore rating in prerequisite when zero ([b375702](https://github.com/Optolith/entity-descriptions/commit/b375702ea644fc21b92bb64b811e204aeda7370c))
+* render ap value from explicit select options ([df2178f](https://github.com/Optolith/entity-descriptions/commit/df2178fe131ed9e9d3427ee092a46b2448b09650))
+
+## [0.4.14](https://github.com/Optolith/entity-descriptions/compare/v0.4.13...v0.4.14) (2026-06-07)
+
+
+### Bug Fixes
+
+* display negative disadvantage AP values ([8dd72a0](https://github.com/Optolith/entity-descriptions/commit/8dd72a04ef10aeb300b54ed8fa25ddfb60318a3e))
+* render shorter variant of commonness-rated options ([9f9eae0](https://github.com/Optolith/entity-descriptions/commit/9f9eae0af0800b17247aa2db8c300e0f693eb336))
+* separate variant values and concluding text with a period ([d58ebeb](https://github.com/Optolith/entity-descriptions/commit/d58ebeb35839ced633ba7a47bf6c69283522803d))
+* sort commonness-rated options alphabetically ([25c50dd](https://github.com/Optolith/entity-descriptions/commit/25c50dde77a34a207eb129fbe9ef63bb41e589cc))
+* sort skill spec skill options ([5b63ea8](https://github.com/Optolith/entity-descriptions/commit/5b63ea8244bc499027069e2edd1f48064bf98df4))
+* wrap skill spec options in parens if needed ([dd0562b](https://github.com/Optolith/entity-descriptions/commit/dd0562bfd09b7cf11d8e9c277b3fdcfba11204bc))
+
 ## [0.4.13](https://github.com/Optolith/entity-descriptions/compare/v0.4.12...v0.4.13) (2026-06-01)
 
 

package/lib/entities/activatable.d.ts

@@ -47,7 +47,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" | "InstrumentEnchantment" | "KarmaSpecialAbility" | "Krallenkettenzauber" | "Kristallkugelzauber" | "LiturgicalStyleSpecialAbility" | "LycantropicGift" | "MagicalSign" | "MagicalSpecialAbility" | "MagicalTradition" | "MagicStyleSpecialAbility" | "OrbEnchantment" | "PactGift" | "ProtectiveWardingCircleSpecialAbility" | "RingEnchantment" | "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">;
+    getInstanceById: GetInstanceById<"Publication" | "Subject" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "TradeSecret" | "Aspect" | "Property" | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Weapon" | "Patron" | "PersonalityTrait">;
     getAllInstances: GetAllInstances<"Script">;
     getResolvedSelectOptionById: GetResolvedSelectOptionById;
     getAllResolvedSelectOptions: GetAllResolvedSelectOptions;

package/lib/entities/activatable.js

@@ -705,8 +705,11 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
         : entityName === "MagicalTradition"
             ? renderAdditionalSpecialRules(translation.name, translation.nameOfSpellcasters, undefined, undefined, undefined, entry.primary).run(env)
             : [];
+    const makeTraditionName = entityName === "BlessedTradition" || entityName === "MagicalTradition"
+        ? name => translate("Tradition ({$tradition})", { tradition: name })
+        : name => name;
     return {
-        title: (translation.name_in_library ?? translation.name) +
+        title: makeTraditionName(translation.name_in_library ?? translation.name) +
             (baseEntry.levels !== undefined ? ` I–${romanize(baseEntry.levels)}` : ""),
         subtitle: mapNullable(baseEntry.usage_type, usageType => {
             switch (usageType.kind) {
@@ -807,7 +810,7 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
                                 }
                                 const { parent: parentId } = selectOption.content;
                                 return locale.translateMap(getInstanceById(parentId.kind, fromUniformCase(parentId))?.translations)?.name;
-                            }, () => getAllResolvedSelectOptions(wrappedId), getAllInstances, apValue, entry, translation) + append,
+                            }, () => getAllResolvedSelectOptions(wrappedId), getAllInstances, apValue, entry, translation, entityName === "Disadvantage") + append,
                         };
                     }),
                 ],

package/lib/entities/culture.js

@@ -109,7 +109,16 @@ const renderCommonProfessions = (getChildInstancesForInstanceId, commonProfessio
                     default:
                         return assertExhaustive(constraint);
                 }
-            }).then(magic => renderCommonProfessionGroup("Blessed Professions", commonProfessions.Grouped.blessed, constraint => renderTraditionConstraint(getChildInstancesForInstanceId, "BlessedTradition", constraint.Tradition)).map(blessed => [
+            }).then(magic => renderCommonProfessionGroup("Blessed Professions", commonProfessions.Grouped.blessed, constraint => {
+                switch (constraint.kind) {
+                    case "Profession":
+                        return renderProfessionConstraint(getChildInstancesForInstanceId, constraint.Profession);
+                    case "Tradition":
+                        return renderTraditionConstraint(getChildInstancesForInstanceId, "BlessedTradition", constraint.Tradition);
+                    default:
+                        return assertExhaustive(constraint);
+                }
+            }).map(blessed => [
                 {
                     type: "definitionList",
                     style: "nested",

package/lib/entities/elixir.d.ts

@@ -5,6 +5,6 @@ import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single
  * Get a JSON representation of the rules text for an elixir.
  */
 export declare const getElixirEntityDescription: import("../creator.js").EntityDescriptionCreator<"Elixir", {
-    getInstanceById: GetInstanceById<"Publication" | "DerivedCharacteristic" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Aspect" | "Property">;
+    getInstanceById: GetInstanceById<"Publication" | "DerivedCharacteristic" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Aspect" | "Property" | "PersonalityTrait">;
     getResolvedSelectOptionById: GetResolvedSelectOptionById;
 }, import("../index.js").EntityDescription>;

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

@@ -6,4 +6,4 @@ import type { BaseActivatable, BaseActivatableTranslation } from "../activatable
 /**
  * Renders an adventure points value to a human-readable string, using the provided locale for translations and formatting. For values that depend on select options or other instances, the necessary lookup functions are provided as arguments.
  */
-export declare const renderAdventurePointsValue: (locale: LocaleEnvironment, getNameForId: (id: ActivatableIdentifier) => string | undefined, getNameForSelectOptionId: (id: ResolvedSelectOptionIdentifier) => string | undefined, getAllSelectOptions: () => ResolvedSelectOption[], getAllInstances: GetAllInstances<"Script" | "AnimalShapeSize">, value: AdventurePointsValue | number, entry: BaseActivatable, translation: BaseActivatableTranslation) => string;
+export declare const renderAdventurePointsValue: (locale: LocaleEnvironment, getNameForId: (id: ActivatableIdentifier) => string | undefined, getNameForSelectOptionId: (id: ResolvedSelectOptionIdentifier) => string | undefined, getAllSelectOptions: () => ResolvedSelectOption[], getAllInstances: GetAllInstances<"Script" | "AnimalShapeSize">, value: AdventurePointsValue | number, entry: BaseActivatable, translation: BaseActivatableTranslation, negative: boolean) => string;

package/lib/entities/partial/adventurePointsValue.js

@@ -1,11 +1,41 @@
 import { on } from "@elyukai/utils/function";
+import { isNotNullish } from "@elyukai/utils/nullable";
 import { unique } from "@optolith/helpers/array";
 import { deepEqual, numAsc } from "@optolith/helpers/compare";
 import { romanize } from "@optolith/helpers/roman";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { evaluateMathOperation } from "./mathOperation.js";
 import { MISSING_VALUE } from "./unknown.js";
-const renderSelectOptionsAdventurePointsValue = (locale, derivedLabel, getAllSelectOptions, getNameForSelectOptionId, config) => {
+const typographicSign = (num) => (num > 0 ? "" : "−") + Math.abs(num).toFixed();
+const renderFixedSelectOptionsAdventurePointsValue = (locale, getAllSelectOptions, getNameForSelectOptionId, getApValueForSelectOption, applyNegative) => {
+    const entriesMap = Map.groupBy(getAllSelectOptions().map((item) => [
+        getApValueForSelectOption(item, item.id),
+        item,
+    ]), item => item[0])
+        .entries()
+        .toArray();
+    if (entriesMap.every((entry) => typeof entry[0] === "number" && entry[1].length === 1)) {
+        const entriesSortedByApValue = entriesMap.toSorted(on(item => item[0], numAsc));
+        return entriesSortedByApValue
+            .map(entry => locale.translateMap(entry[1][0][1].content.translations)?.name ?? MISSING_VALUE)
+            .join("/")
+            .concat(`: ${locale.translate("{$value} Adventure Points", { value: entriesSortedByApValue.map(entry => typographicSign(applyNegative(entry[0]))).join("/") })}`);
+    }
+    else {
+        return entriesMap
+            .map(([apValue, items]) => [
+            apValue,
+            locale.join(items
+                .map(item => getNameForSelectOptionId(item[1].id))
+                .filter(name => name !== undefined)
+                .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 })}`)
+            .join("; ");
+    }
+};
+const renderSelectOptionsAdventurePointsValue = (locale, derivedLabel, getAllSelectOptions, getNameForSelectOptionId, config, applyNegative) => {
     if (config === undefined) {
         return MISSING_VALUE;
     }
@@ -18,23 +48,8 @@ const renderSelectOptionsAdventurePointsValue = (locale, derivedLabel, getAllSel
             })}`;
         }
         case "Fixed":
-            return Map.groupBy(getAllSelectOptions().map((item) => [
-                config.Fixed.map.find(mapItem => deepEqual(mapItem.id, item.id))?.ap_value ??
-                    config.Fixed.default,
-                item,
-            ]), item => item[0])
-                .entries()
-                .map(([apValue, items]) => [
-                apValue,
-                locale.join(items
-                    .map(item => getNameForSelectOptionId(item[1].id))
-                    .filter(name => name !== undefined)
-                    .toSorted(locale.compare), "conjunction"),
-            ])
-                .toArray()
-                .toSorted(on(item => item[1], locale.compare))
-                .map(([apValue, itemNames]) => `${itemNames}: ${locale.translate("{$value} Adventure Points", { value: apValue })}`)
-                .join("; ");
+            return renderFixedSelectOptionsAdventurePointsValue(locale, getAllSelectOptions, getNameForSelectOptionId, item => config.Fixed.map.find(mapItem => deepEqual(mapItem.id, item.id))?.ap_value ??
+                config.Fixed.default, applyNegative);
         default:
             return assertExhaustive(config);
     }
@@ -42,23 +57,26 @@ const renderSelectOptionsAdventurePointsValue = (locale, derivedLabel, getAllSel
 /**
  * Renders an adventure points value to a human-readable string, using the provided locale for translations and formatting. For values that depend on select options or other instances, the necessary lookup functions are provided as arguments.
  */
-export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelectOptionId, getAllSelectOptions, getAllInstances, value, entry, translation) => {
+export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelectOptionId, getAllSelectOptions, getAllInstances, value, entry, translation, negative) => {
     const { translate, translateMap } = locale;
+    const applyNegative = negative
+        ? numValue => -numValue
+        : numValue => numValue;
     if (typeof value === "number") {
         return translate(".input {$value :number} {{{$value} Adventure Points}}", {
-            value,
+            value: applyNegative(value),
         });
     }
     switch (value.kind) {
         case "Fixed": {
             if (entry.levels === undefined) {
                 return translate(".input {$value :number} {{{$value} Adventure Points}}", {
-                    value: value.Fixed,
+                    value: applyNegative(value.Fixed),
                 });
             }
             else {
                 return translate(".input {$value :number} {{{$value} Adventure Points per level}}", {
-                    value: value.Fixed,
+                    value: applyNegative(value.Fixed),
                 });
             }
         }
@@ -68,7 +86,7 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
             }
             const mainValue = `${translate("Level {$level}", {
                 level: Array.from({ length: entry.levels }, (_, index) => romanize(index + 1)).join("/"),
-            })}: ${value.ByLevel.list.join("/")}`;
+            })}: ${value.ByLevel.list.map(applyNegative).join("/")}`;
             const { additionalBySizeCategory } = value.ByLevel;
             if (additionalBySizeCategory === undefined) {
                 return mainValue;
@@ -76,7 +94,7 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
             else {
                 const sizeCategories = ["tiny", "small", "medium", "large", "huge"];
                 const values = sizeCategories
-                    .map(sizeCategory => additionalBySizeCategory[sizeCategory])
+                    .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 })}`;
@@ -85,7 +103,25 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
         case "DerivedFromSelection": {
             const derivedSelectOptions = entry.select_options?.derived;
             if (derivedSelectOptions === undefined) {
-                return MISSING_VALUE;
+                return renderFixedSelectOptionsAdventurePointsValue(locale, getAllSelectOptions, getNameForSelectOptionId, item => {
+                    switch (item.content.ap_value?.kind) {
+                        case "Fixed":
+                            return item.content.ap_value.Fixed;
+                        case "DependingOnActiveInstances":
+                            switch (item.content.ap_value.DependingOnActiveInstances.kind) {
+                                case "Threshold":
+                                    return item.content.ap_value.DependingOnActiveInstances.Threshold.normal;
+                                case "Expression":
+                                    return MISSING_VALUE;
+                                default:
+                                    return assertExhaustive(item.content.ap_value.DependingOnActiveInstances);
+                            }
+                        case undefined:
+                            return MISSING_VALUE;
+                        default:
+                            return assertExhaustive(item.content.ap_value);
+                    }
+                }, applyNegative);
             }
             switch (derivedSelectOptions.kind) {
                 case "Blessings":
@@ -98,14 +134,15 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
                     return translate("{$value} Adventure Points", {
                         value: unique(getAllInstances("Script")
                             .map(script => script.content.ap_value)
-                            .filter(apValue => apValue !== undefined))
+                            .filter(isNotNullish))
                             .toSorted(numAsc)
+                            .map(applyNegative)
                             .join("/"),
                     });
                 case "AnimalShapes": {
                     const sizes = getAllInstances("AnimalShapeSize").toSorted(on(x => x.content.ap_value, numAsc));
                     return translate("{$values} adventure points for a {$sized} animal shape", {
-                        values: sizes.map(size => size.content.ap_value).join("/"),
+                        values: sizes.map(size => applyNegative(size.content.ap_value)).join("/"),
                         sized: sizes
                             .map(size => translateMap(size.content.translations)?.name ?? MISSING_VALUE)
                             .join("/"),
@@ -179,9 +216,9 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
                             default:
                                 return translate("A/B/C/D ability");
                         }
-                    }, getAllSelectOptions, getNameForSelectOptionId, derivedSelectOptions.Skills.ap_value);
+                    }, getAllSelectOptions, getNameForSelectOptionId, derivedSelectOptions.Skills.ap_value, applyNegative);
                 case "CombatTechniques":
-                    return renderSelectOptionsAdventurePointsValue(locale, () => translate("B/C/D combat technique"), getAllSelectOptions, getNameForSelectOptionId, derivedSelectOptions.CombatTechniques.ap_value);
+                    return renderSelectOptionsAdventurePointsValue(locale, () => translate("B/C/D combat technique"), getAllSelectOptions, getNameForSelectOptionId, derivedSelectOptions.CombatTechniques.ap_value, applyNegative);
                 case "TargetCategories":
                     return MISSING_VALUE;
                 default:

package/lib/entities/partial/commonnessRatedAdvantagesAndDisadvantages.js

@@ -27,7 +27,7 @@ const makeActivatableIdentifierForCommonnessRatedAdvantageOrDisadvantage = (enti
             return assertExhaustive(entity);
     }
 };
-const renderCommonnessRatedAdvantageOrDisadvantageName = (translateMap, getInstanceById, getResolvedSelectOptionById, entity, item) => {
+const renderCommonnessRatedAdvantageOrDisadvantageName = (translateMap, getInstanceById, getResolvedSelectOptionById, localeCompare, entity, item) => {
     const customTranslation = translateMap(item.translations);
     return (attributedCustomName(translateMap, getInstanceById, entity, (translation, instance) => {
         if (customTranslation?.full !== undefined) {
@@ -38,7 +38,7 @@ const renderCommonnessRatedAdvantageOrDisadvantageName = (translateMap, getInsta
             ? undefined
             : convertCommonnessRatedAdvantageOrDisadvantageLevel(item.level);
         const options = customTranslation?.options === undefined
-            ? (item.options?.map(option => renderNameComponentsOptions(false, getResolvedSelectOptionById, id, [option]) ??
+            ? (item.options?.map(option => renderNameComponentsOptions(true, getResolvedSelectOptionById, id, [option]) ??
                 MISSING_VALUE) ?? [])
             : [customTranslation.options];
         const name = translation.name_in_library !== undefined && options.length === 0
@@ -49,12 +49,8 @@ const renderCommonnessRatedAdvantageOrDisadvantageName = (translateMap, getInsta
             base: name,
             level,
             nameBuilderRules: makeNameBuilderRulesWithDefaults(instance.nameBuilderRules),
-            options: customTranslation?.options === undefined
-                ? (item.options?.map(option => renderNameComponentsOptions(false, getResolvedSelectOptionById, id, [
-                    option,
-                ]) ?? MISSING_VALUE) ?? [])
-                : [customTranslation.options],
-        }, false);
+            options,
+        }, false, list => list.toSorted(localeCompare).join(", "));
     }, entity, item.id) ?? MISSING_VALUE);
 };
 /**
@@ -63,13 +59,13 @@ const renderCommonnessRatedAdvantageOrDisadvantageName = (translateMap, getInsta
 export const renderCommonnessRatedAdvantagesOrDisadvantages = (entity, items, emptyString) => Reader.asks(({ translateMap, getInstanceById, getResolvedSelectOptionById, localeCompare }) => items === undefined || !isNotEmpty(items)
     ? emptyString
     : items
-        .map(item => renderCommonnessRatedAdvantageOrDisadvantageName(translateMap, getInstanceById, getResolvedSelectOptionById, entity, item))
+        .map(item => renderCommonnessRatedAdvantageOrDisadvantageName(translateMap, getInstanceById, getResolvedSelectOptionById, localeCompare, entity, item))
         .toSorted(localeCompare)
         .join(", "));
 /**
  * Render the names of commonness-rated advantages and disadvantages together.
  */
-export const renderCommonnessRatedAdvantagesAndDisadvantages = (advantages, disadvantages, emptyString) => Reader.asks(({ translateMap, getInstanceById, getResolvedSelectOptionById, localeCompare }) => mapNullable(ensureNonEmpty([["Advantage", advantages], ["Disadvantage", disadvantages]].flatMap(([entity, items]) => items?.map(item => renderCommonnessRatedAdvantageOrDisadvantageName(translateMap, getInstanceById, getResolvedSelectOptionById, entity, item)) ?? [])), renderedItems => renderedItems.toSorted(localeCompare).join(", ")) ?? emptyString);
+export const renderCommonnessRatedAdvantagesAndDisadvantages = (advantages, disadvantages, emptyString) => Reader.asks(({ translateMap, getInstanceById, getResolvedSelectOptionById, localeCompare }) => mapNullable(ensureNonEmpty([["Advantage", advantages], ["Disadvantage", disadvantages]].flatMap(([entity, items]) => items?.map(item => renderCommonnessRatedAdvantageOrDisadvantageName(translateMap, getInstanceById, getResolvedSelectOptionById, localeCompare, entity, item)) ?? [])), renderedItems => renderedItems.toSorted(localeCompare).join(", ")) ?? emptyString);
 /**
  * Render a value with a possible translation, falling back to explicity rendering the value if no translation is available.
  */

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

@@ -13,11 +13,11 @@ export declare const printPublicationPrerequisites: (getInstanceById: GetInstanc
 /**
  * Print plain general prerequisites as a string.
  */
-export declare const printPlainGeneralPrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: PlainGeneralPrerequisites) => string;
+export declare const printPlainGeneralPrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement" | "PersonalityTrait">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: PlainGeneralPrerequisites) => string;
 /**
  * Print general prerequisites as a string.
  */
-export declare const printGeneralPrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: GeneralPrerequisites, printPreviousLevelPrerequisites?: {
+export declare const printGeneralPrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement" | "PersonalityTrait">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: GeneralPrerequisites, printPreviousLevelPrerequisites?: {
     id: ActivatableIdentifier;
     levels: number;
 }, trailingText?: string) => string;
@@ -28,7 +28,7 @@ export declare const printProfessionPrerequisites: (getInstanceById: GetInstance
 /**
  * Print advantage disadvantage prerequisites as a string.
  */
-export declare const printAdvantageDisadvantagePrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: AdvantageDisadvantagePrerequisites, name: string, type: "Advantage" | "Disadvantage") => string;
+export declare const printAdvantageDisadvantagePrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement" | "PersonalityTrait">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: AdvantageDisadvantagePrerequisites, name: string, type: "Advantage" | "Disadvantage") => string;
 /**
  * Print arcane tradition prerequisites as a string.
  */

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

@@ -14,7 +14,7 @@ export declare const printPublicationPrerequisiteGroup: (getInstanceById: GetIns
 /**
  * Print the translation of a general prerequisite group.
  */
-export declare const printGeneralPrerequisiteGroup: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, prerequisite: GeneralPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printGeneralPrerequisiteGroup: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement" | "PersonalityTrait">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, prerequisite: GeneralPrerequisiteGroup) => PrerequisitePart | undefined;
 /**
  * Print the translation of a profession prerequisite group.
  */
@@ -22,7 +22,7 @@ export declare const printProfessionPrerequisiteGroup: (getInstanceById: GetInst
 /**
  * Print the translation of an advantage/disadvantage prerequisite group.
  */
-export declare const printAdvantageDisadvantagePrerequisiteGroup: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, prerequisite: AdvantageDisadvantagePrerequisiteGroup, name: string, type: "Advantage" | "Disadvantage") => PrerequisitePart | undefined;
+export declare const printAdvantageDisadvantagePrerequisiteGroup: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement" | "PersonalityTrait">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, prerequisite: AdvantageDisadvantagePrerequisiteGroup, name: string, type: "Advantage" | "Disadvantage") => PrerequisitePart | undefined;
 /**
  * Print the translation of an arcane tradition prerequisite group.
  */

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

@@ -87,6 +87,8 @@ export const printGeneralPrerequisiteGroup = (getInstanceById, getResolvedSelect
             return printTextPrerequisite(locale, prerequisite.Text);
         case "SexualCharacteristic":
             return printSexualCharacteristicPrerequisite(locale, prerequisite.SexualCharacteristic);
+        case "PersonalityTrait":
+            return printPersonalityTraitPrerequisite(getInstanceById, locale, prerequisite.PersonalityTrait);
         default:
             return assertExhaustive(prerequisite);
     }
@@ -136,6 +138,7 @@ export const printAdvantageDisadvantagePrerequisiteGroup = (getInstanceById, get
         case "Enhancement":
         case "Text":
         case "SexualCharacteristic":
+        case "PersonalityTrait":
             return printGeneralPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite);
         default:
             return assertExhaustive(prerequisite);

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

@@ -8,8 +8,9 @@ export const printRatedPrerequisite = (getInstanceById, locale, prerequisite) =>
     if (prerequisite.display_option !== undefined) {
         return printDisplayOption(locale.translateMap, prerequisite.display_option);
     }
+    const name = attributedCustomName(locale.translateMap, getInstanceById, "prerequisite", (t) => t.abbreviation ?? t.name, prerequisite.id) ?? MISSING_VALUE;
     return {
-        value: `${attributedCustomName(locale.translateMap, getInstanceById, "prerequisite", (t) => t.abbreviation ?? t.name, prerequisite.id) ?? MISSING_VALUE} ${prerequisite.value.toFixed()}`,
+        value: prerequisite.value > 0 ? `${name} ${prerequisite.value.toFixed()}` : name,
         sentenceType: undefined,
         isMeta: false,
     };

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

@@ -1,7 +1,8 @@
 import { Reader } from "@elyukai/utils/reader";
 import type { CheckResultBasedModifier, DurationUnitValue, ElvenMagicalSongPermanentCost, FirstPersonMagicalMelodyCost, NonModifiableOneTimeCostPerCountable, NonModifiableSustainedCost, OneTimeCost, OneTimeCostMap, ResponsiveText, ResponsiveTextOptional, ResponsiveTextReplace, SkillModificationLevel_ID, SustainedCost } from "@optolith/database-schema/gen";
-import { type LocaleMap } from "../../../../helpers/translate.js";
+import { type LocaleMap, type Translate } from "../../../../helpers/translate.js";
 import { type StdEnv, type StdReader } from "../../reader.js";
+import { type ResponsiveTextSize } from "../../responsiveText.js";
 /**
  * Returns the text for the modifiable one-time cost of an activatable skill.
  */
@@ -51,11 +52,11 @@ export declare const renderOneTimeCost: (value: OneTimeCost) => StdReader<string
  * Returns the text for the non-modifiable cost of a sustained activatable skill.
  */
 export declare const renderNonModifiableSustainedCost: (value: NonModifiableSustainedCost) => Reader<{
-    translate: import("../../../../helpers/translate.js").Translate;
+    translate: Translate;
     energyUnit: import("../../units/energy.js").EnergyUnit;
 } & {
-    translate: import("../../../../helpers/translate.js").Translate;
-    responsiveTextSize: import("../../responsiveText.js").ResponsiveTextSize;
+    translate: Translate;
+    responsiveTextSize: ResponsiveTextSize;
 } & StdEnv<"t" | "rts" | "tm" | "eu", never, never, never>, string>;
 /**
  * Returns the text for the cost of a sustained activatable skill.

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

@@ -2,10 +2,11 @@ import { identity } from "@elyukai/utils/function";
 import { Reader } from "@elyukai/utils/reader";
 import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { responsiveTranslate, } from "../../../../helpers/translate.js";
 import { renderResponsiveMap } from "../../map.js";
 import { formatEnergyFnR, formatEnergyR, getInstanceByIdFnR, modifiableBySpeedR, responsiveLocaleJoinR, responsiveR, responsiveTextR, responsiveTranslateR, translateMapR, translateR, } from "../../reader.js";
-import { appendNoteIfNeeded, replaceTextIfNeeded } from "../../responsiveText.js";
-import { formatCombinedTimeSpanR } from "../../units/timeSpan.js";
+import { appendNoteIfNeeded, replaceTextIfNeeded, } from "../../responsiveText.js";
+import { formatCombinedTimeSpan, formatCombinedTimeSpanR } from "../../units/timeSpan.js";
 import { MISSING_VALUE } from "../../unknown.js";
 import { appendCheckResultModifier } from "./checkResultBased.js";
 import { wrapIfMinimum } from "./isMinimumMaximum.js";
@@ -57,12 +58,18 @@ export const renderModifiableOneTimeCost = (value) => deriveModifiableCost(value
         }
         return responsiveTextR(translation.additional).map(additional => `${text} + ${additional}`);
     })));
-const appendIntervalToCost = (interval, baseCost) => interval === undefined
+const appendIntervalToCostR = (interval, baseCost) => interval === undefined
     ? Reader.of(baseCost)
     : formatCombinedTimeSpanR(interval, true).then(formattedInterval => responsiveTranslateR("{$cost} per {$interval}", "{$cost}/{$interval}", {
         cost: baseCost,
         interval: formattedInterval,
     }));
+const appendIntervalToCost = (translate, responsiveTextSize, interval, baseCost) => interval === undefined
+    ? baseCost
+    : responsiveTranslate(translate, responsiveTextSize, "{$cost} per {$interval}", "{$cost}/{$interval}", {
+        cost: baseCost,
+        interval: formatCombinedTimeSpan(translate, responsiveTextSize, interval, true),
+    });
 /**
  * Returns the text for a non-modifiable one-time cost of an activatable skill.
  */
@@ -70,7 +77,7 @@ export const renderNonModifiableOneTimeCost = (value, shouldAppendNonModifiableS
     .thenW(base => appendFamiliarsTrickLPCostIfNeeded(value.lp_value, base))
     .thenW(base => appendPerCountableToCostIfNeeded(value.per, base))
     .then(base => appendPermanentCostIfNeeded(value.permanent_value, base))
-    .then(base => appendIntervalToCost(value.interval, base))
+    .then(base => appendIntervalToCostR(value.interval, base))
     .then(base => appendElvenPermanentCostIfNeeded(value.permanent, base))
     .then(base => wrapIfMinimum(value.is_minimum, base))
     .then(base => appendNoteIfNeeded(value.translations, base))
@@ -126,7 +133,7 @@ export const renderOneTimeCostMap = (value) => Reader.asks(({ translate }) => tr
     : undefined))
     .then(text => appendNonModifiableSuffix(ModifiableParameter.Cost, text)));
 const renderSustainedCostMap = (value) => formatEnergyFnR
-    .thenW(formatEnergy => renderResponsiveMap(value, option => option.value, formatEnergy))
+    .thenW(formatEnergy => Reader.ask().thenW(({ translate, responsiveTextSize }) => renderResponsiveMap(value, option => option.value, singleValue => appendIntervalToCost(translate, responsiveTextSize, value.interval, formatEnergy(singleValue)))))
     .then(text => appendNonModifiableSuffix(ModifiableParameter.Cost, text));
 /**
  * Returns the text for the cost of a one-time activatable skill.
@@ -147,7 +154,7 @@ export const renderOneTimeCost = (value) => {
 };
 const buildSustainedCost = (activationCost, intervalCost, interval) => {
     const activationCostWithLabel = responsiveR(() => translateR("activation").map(label => `${activationCost} (${label})`), () => Reader.of(activationCost)).thenW(identity);
-    const intervalCostWithLabel = appendIntervalToCost(interval, intervalCost);
+    const intervalCostWithLabel = appendIntervalToCostR(interval, intervalCost);
     return activationCostWithLabel.map2(intervalCostWithLabel, (activationStr, intervalStr) => `${activationStr} + ${intervalStr}`);
 };
 const renderModifiableSustainedCost = (value) => deriveModifiableCost(value.initial_modification_level).thenW(cost => cost === undefined

package/lib/entities/partial/units/timeSpan.d.ts

@@ -12,6 +12,15 @@ export type TimeSpanUnit = "Seconds" | "Minutes" | "Hours" | "Days" | "Weeks" |
 export declare const formatTimeSpan: (translate: Translate, responsiveTextSize: ResponsiveTextSize, unit: {
     kind: TimeSpanUnit;
 } | TimeSpanUnit, value: number | string, interval?: boolean) => string;
+/**
+ * Returns the text for a time span unit.
+ */
+export declare const formatCombinedTimeSpan: (translate: Translate, responsiveTextSize: ResponsiveTextSize, object: {
+    unit: {
+        kind: TimeSpanUnit;
+    };
+    value: number | string;
+}, interval?: boolean) => string;
 /**
  * Returns the text for a time span unit.
  */

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

@@ -28,6 +28,10 @@ export const formatTimeSpan = (translate, responsiveTextSize, unit, value, inter
         style: interval ? "interval" : "default",
     }));
 };
+/**
+ * Returns the text for a time span unit.
+ */
+export const formatCombinedTimeSpan = (translate, responsiveTextSize, object, interval = false) => formatTimeSpan(translate, responsiveTextSize, object.unit, object.value, interval);
 /**
  * Returns the text for a time span unit.
  */

package/lib/entities/poison.d.ts

@@ -6,7 +6,7 @@ import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single
  * Get a JSON representation of the rules text for a poison.
  */
 export declare const getPoisonEntityDescription: import("../creator.js").EntityDescriptionCreator<"Poison", {
-    getInstanceById: GetInstanceById<"Publication" | "DerivedCharacteristic" | "Disease" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Aspect" | "Property">;
+    getInstanceById: GetInstanceById<"Publication" | "DerivedCharacteristic" | "Disease" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Aspect" | "Property" | "PersonalityTrait">;
     getResolvedSelectOptionById: GetResolvedSelectOptionById;
     idMap: IdMap;
 }, import("../index.js").EntityDescription>;

package/lib/entities/profession.js

@@ -77,12 +77,15 @@ const renderVariantLanguagesScriptsOption = (baseOptions, variantOptions) => ren
     })),
 });
 const renderLanguagesScriptsOption = (option) => renderVariantLanguagesScriptsOption(undefined, { kind: "Override", Override: option });
-const renderSkillSpecializationOption = (option) => Reader.asks(({ format, translate, translateMap, localeJoin, getInstanceById }) => {
+const wrapInParensIf = (text, condition) => (condition ? parensIf(text) : text);
+const renderSkillSpecializationOption = (option) => Reader.asks(({ format, translate, translateMap, localeJoin, localeCompare, getInstanceById }) => {
     switch (option.kind) {
         case "Specific":
             return translate("Skill Specialization {$possibleSkills}", {
-                possibleSkills: localeJoin(option.Specific.options.map(id => attributedName(translateMap, getInstanceById, "profession", "Skill", id) ??
-                    MISSING_VALUE), "disjunction"),
+                possibleSkills: wrapInParensIf(localeJoin(option.Specific.options
+                    .map(id => attributedName(translateMap, getInstanceById, "profession", "Skill", id) ??
+                    MISSING_VALUE)
+                    .toSorted(localeCompare), "disjunction"), option.Specific.options.length > 2),
             });
         case "Group":
             return translate("Skill Specialization for a {$skillOfGroup}", {
@@ -563,10 +566,13 @@ const renderProfessionVariantText = (base, variant, translation) => translation.
         renderRatedVariantChanges(base.spells, variant.spells, renderSpellworkName),
         renderBlessingsForVariant(variant),
         renderRatedVariantChanges(baseHasNoTradition(base) ? "ignore" : base.liturgical_chants, variant.liturgical_chants, renderLiturgicalChantName),
-    ]).map(lists => lists
-        .filter(isNotEmpty)
-        .map(list => list.join(", "))
-        .join("; ") + (translation.concluding_text ?? ""));
+    ]).map(lists => {
+        const nonEmptyLists = lists.filter(isNotEmpty);
+        return (nonEmptyLists.map(list => list.join(", ")).join("; ") +
+            (translation.concluding_text !== undefined
+                ? `${nonEmptyLists.length > 0 ? ". " : ""}${translation.concluding_text}`
+                : ""));
+    });
 const renderProfessionVariant = (base, variants) => translateMapFnR.thenW(translateMap => {
     const translations = variants
         .map(variant => mapNullable(translateMap(variant.content.translations), t => ({