@optolith/entity-descriptions 0.5.1 → 0.7.1

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 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.7.1](https://github.com/Optolith/entity-descriptions/compare/v0.7.0...v0.7.1) (2026-09-09)
+## [0.7.0](https://github.com/Optolith/entity-descriptions/compare/v0.6.0...v0.7.0) (2026-09-08)
+
+### ⚠ BREAKING CHANGES
+
+* combat type badges
+* **deps:** upgrade to schema 0.56.0
+
+### build
+
+* **deps:** upgrade to schema 0.56.0 ([b784991](https://github.com/Optolith/entity-descriptions/commit/b784991d8775bf4315e369891601bf37288b884f))
+
+### Features
+
+* combat type badges ([f1824df](https://github.com/Optolith/entity-descriptions/commit/f1824dfd23ae34e6af7334e9e5182c9dbc45603f))
+## [0.6.0](https://github.com/Optolith/entity-descriptions/compare/v0.5.1...v0.6.0) (2026-09-08)
+
+### ⚠ BREAKING CHANGES
+
+* **deps:** upgrade to schema 0.55.0
+
+### build
+
+* **deps:** upgrade to schema 0.55.0 ([0dff095](https://github.com/Optolith/entity-descriptions/commit/0dff0950d939beec0e688e792c58d6d0a2ce44d7))
+
+### Bug Fixes
+
+* restricted blessings for traditions ([ca26c4c](https://github.com/Optolith/entity-descriptions/commit/ca26c4cadc77198b164967074735707ac6ec8593)), closes [#42](https://github.com/Optolith/entity-descriptions/issues/42)
 ## [0.5.1](https://github.com/Optolith/entity-descriptions/compare/v0.5.0...v0.5.1) (2026-09-08)
 ## [0.5.0](https://github.com/Optolith/entity-descriptions/compare/v0.4.26...v0.5.0) (2026-09-08)
 

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" | "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">;
+    getInstanceById: GetInstanceById<"Publication" | "Subject" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "TradeSecret" | "Aspect" | "Property" | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Weapon" | "Patron" | "PersonalityTrait" | "Blessing">;
     getAllInstances: GetAllInstances<"Script">;
     getResolvedSelectOptionById: GetResolvedSelectOptionById;
     getAllResolvedSelectOptions: GetAllResolvedSelectOptions;

package/lib/entities/activatable.js

@@ -1,7 +1,7 @@
 import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { count } from "@elyukai/utils/array/reductions";
 import { deepEqual } from "@elyukai/utils/equality";
-import { on } from "@elyukai/utils/function";
+import { constant, on } from "@elyukai/utils/function";
 import { isNotNullish } from "@elyukai/utils/nullable";
 import { Reader } from "@elyukai/utils/reader";
 import { numAsc } from "@optolith/helpers/compare";
@@ -100,7 +100,7 @@ const renderPenaltyValue = (getInstanceById, translate, translateMap, name, pena
         case "ByAttack": {
             const offset = penalty.ByAttack.initial_order ?? 1;
             return penalty.ByAttack.list
-                .map((penaltyByAttack, index) => `${penaltyByAttack.value.toFixed()} (${renderPenaltyByAttackLabel(translate, penalty.ByAttack.attack_replacement, index + offset)})`)
+                .map((penaltyByAttack, index) => `${sign(penaltyByAttack.value)} (${renderPenaltyByAttackLabel(translate, penalty.ByAttack.attack_replacement, index + offset)})`)
                 .join("; ");
         }
         case "DependsOnHitZone":
@@ -651,6 +651,37 @@ const renderFavoredSkillsSelection = (baseList, favoredSkillsSelection) => favor
         baseList,
         selection: names.join(", "),
     }));
+const getRestrictedBlessingsSpecialRuleLabelKey = (restrictedBlessings) => {
+    if (restrictedBlessings === "All") {
+        return "No Blessings";
+    }
+    switch (restrictedBlessings.kind) {
+        case "Three":
+            return "Restricted Blessings";
+        case "Six":
+            return "Strongly Restricted Blessings";
+        default:
+            return assertExhaustive(restrictedBlessings);
+    }
+};
+const renderRestrictedBlessingsSpecialRule = (restrictedBlessings, nameOfPeopleWithThisTradition) => translateR(getRestrictedBlessingsSpecialRuleLabelKey(restrictedBlessings)).thenW(label => restrictedBlessings === "All"
+    ? translateR("{$nameOfBlessedOnes} cannot use blessings.", {
+        nameOfBlessedOnes: nameOfPeopleWithThisTradition,
+    }).map(text => ({
+        label,
+        text,
+    }))
+    : Reader.traverse(restrictedBlessings.kind === "Three"
+        ? restrictedBlessings.Three
+        : restrictedBlessings.Six, id => attributedNameR("restricted-blessings", "Blessing", id).map(name => name ?? MISSING_VALUE))
+        .thenW(localeSortR)
+        .thenW(list => translateR("{$nameOfBlessedOnes} cannot use {$blessings :list type=disjunction}.", {
+        nameOfBlessedOnes: nameOfPeopleWithThisTradition,
+        blessings: list,
+    }).map(text => ({
+        label,
+        text,
+    }))));
 const renderFavoredSkillsSpecialRule = (favoredCombatTechniques, favoredSkills, favoredSkillsSelection) => translateR("Favored Skills").thenW(label => renderFavoredCombatTechniques(favoredCombatTechniques)
     .thenW(favoredCombatTechniquesText => renderFavoredSkillsBaseList(favoredCombatTechniquesText, favoredSkills))
     .thenW(list => renderFavoredSkillsSelection(list, favoredSkillsSelection))
@@ -670,7 +701,11 @@ const renderPrimaryAttributeSpecialRule = (traditionName, nameOfPeopleWithThisTr
         }))).map(description => ({
     text: description,
 }));
-const renderAdditionalSpecialRules = (traditionName, nameOfPeopleWithThisTradition, favoredCombatTechniques, favoredSkills, favoredSkillsSelection, primaryAttribute) => Reader.sequence([
+const renderAdditionalSpecialRules = (fixedSpecialRules, traditionName, nameOfPeopleWithThisTradition, restrictedBlessings, favoredCombatTechniques, favoredSkills, favoredSkillsSelection, primaryAttribute) => Reader.sequence([
+    restrictedBlessings === undefined
+        ? Reader.of(undefined)
+        : renderRestrictedBlessingsSpecialRule(restrictedBlessings, nameOfPeopleWithThisTradition),
+    ...fixedSpecialRules.map(rule => Reader.of(rule)),
     favoredSkills === undefined
         ? Reader.of(undefined)
         : renderFavoredSkillsSpecialRule(favoredCombatTechniques, favoredSkills, favoredSkillsSelection),
@@ -691,14 +726,15 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
         translateMap,
         getInstanceById,
         localeCompare: locale.compare,
+        localeJoin: locale.join,
     };
     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)
+    const addAdditionalSpecialRules = entityName === "BlessedTradition"
+        ? (baseList) => renderAdditionalSpecialRules(baseList, translation.name, translation.nameOfBlessedOnes, entry.type.kind === "Church" ? entry.type.Church.restrictedBlessings : "All", 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)
-            : [];
+            ? (baseList) => renderAdditionalSpecialRules(baseList, translation.name, translation.nameOfSpellcasters, undefined, undefined, undefined, undefined, entry.primary).run(env)
+            : constant([]);
     const makeTraditionName = entityName === "BlessedTradition" || entityName === "MagicalTradition"
         ? name => translate("Tradition ({$tradition})", { tradition: name })
         : name => name;
@@ -719,12 +755,23 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
                     return assertExhaustive(usageType);
             }
         }),
+        badge: mapNullable(entityName === "CombatStyleSpecialAbility" || entityName === "AdvancedCombatSpecialAbility"
+            ? entry.type
+            : undefined, combatType => {
+            switch (combatType.kind) {
+                case "Armed":
+                    return { type: "armedCombat", value: translate("AC") };
+                case "Unarmed":
+                    return { type: "unarmedCombat", value: translate("UC") };
+                default:
+                    return assertExhaustive(combatType);
+            }
+        }),
         className: "special-ability",
         body: [
             mapNullable(translation.special_rules, specialRules => ({
                 type: "plain",
-                text: specialRules
-                    .concat(additionalSpecialRules)
+                text: addAdditionalSpecialRules(specialRules)
                     .map(specialRule => specialRule.label === undefined
                     ? `- ${specialRule.text}`
                     : `- *${specialRule.label}*: ${specialRule.text}`)

package/lib/entities/focusRule.js

@@ -11,7 +11,7 @@ export const getFocusRuleEntityDescription = createEntityDescriptionCreator(({ g
     }
     return {
         title: translation.name,
-        badge: entry.level,
+        badge: { type: "level", value: romanize(entry.level) },
         className: "focus-rule",
         body: [
             {

package/lib/entities/liturgicalChant.js

@@ -17,16 +17,19 @@ const getTextForBlessingTraditions = (deps, id) => {
     const blessedTraditions = deps.getAllInstances("BlessedTradition");
     const primaryTradition = blessedTraditions.find(trad => trad.content.primaryBlessing === id);
     const secondaryTraditions = blessedTraditions.filter(trad => {
-        switch (trad.content.restricted_blessings?.kind) {
-            case "Six":
-                return !trad.content.restricted_blessings.Six.includes(id);
-            case "Three":
-                return !trad.content.restricted_blessings.Three.includes(id);
-            case undefined:
-                return false;
-            default:
-                return assertExhaustive(trad.content.restricted_blessings);
+        if (trad.content.type.kind === "Church") {
+            switch (trad.content.type.Church.restrictedBlessings?.kind) {
+                case "Six":
+                    return !trad.content.type.Church.restrictedBlessings.Six.includes(id);
+                case "Three":
+                    return !trad.content.type.Church.restrictedBlessings.Three.includes(id);
+                case undefined:
+                    return false;
+                default:
+                    return assertExhaustive(trad.content.type.Church.restrictedBlessings);
+            }
         }
+        return false;
     });
     const translateTradition = (trad) => {
         const traditionTranslation = deps.translateMap(trad.content.translations);

package/lib/entities/profession.js

@@ -471,25 +471,27 @@ const renderRestrictedBlessings = (restrictedBlessings) => {
             return assertExhaustive(restrictedBlessings);
     }
 };
-const renderSingleBlessings = (traditions) => Reader.traverse(traditions, traditionId => getInstanceByIdR("BlessedTradition", traditionId).map(tradition => tradition
-    ? { restrictedBlessings: tradition.restricted_blessings, type: tradition.type }
-    : undefined)).thenW(restrictedBlessingsList => !isNotEmpty(restrictedBlessingsList)
+const renderSingleBlessings = (traditions) => Reader.traverse(traditions, traditionId => getInstanceByIdR("BlessedTradition", traditionId).map(tradition => tradition?.type))
+    .map(traditionTypes => traditionTypes.filter(isNotNullish))
+    .thenW(traditionTypes => !isNotEmpty(traditionTypes)
     ? Reader.of(undefined)
-    : restrictedBlessingsList.length === 1
+    : traditionTypes.length === 1
         ? (() => {
-            const [first] = restrictedBlessingsList;
-            const { restrictedBlessings, type } = first ?? {};
-            return type?.kind === "Shamanistic"
-                ? Reader.of(undefined)
-                : restrictedBlessings === undefined
-                    ? translateR("The Twelve Blessings")
-                    : translateR("The Twelve Blessings").thenW(base => renderRestrictedBlessings(restrictedBlessings).thenW(list => translateR("except for {$list :list type=conjunction}", {
-                        list,
-                    }).map(note => base + parensIf(note))));
+            const [first] = traditionTypes;
+            if (first.kind === "Shamanistic") {
+                return Reader.of(undefined);
+            }
+            const { restrictedBlessings } = first.Church;
+            return restrictedBlessings === undefined
+                ? translateR("The Twelve Blessings")
+                : translateR("The Twelve Blessings").thenW(base => renderRestrictedBlessings(restrictedBlessings).thenW(list => translateR("except for {$list :list type=conjunction}", {
+                    list,
+                }).map(note => base + parensIf(note))));
         })()
-        : restrictedBlessingsList.every(trad => trad?.type.kind === "Shamanistic")
+        : traditionTypes.every(trad => trad.kind === "Shamanistic")
             ? Reader.of(undefined)
-            : restrictedBlessingsList.some(trad => trad?.restrictedBlessings !== undefined || trad?.type.kind === "Shamanistic")
+            : traditionTypes.some(trad => (trad.kind === "Church" && trad.Church.restrictedBlessings !== undefined) ||
+                trad.kind === "Shamanistic")
                 ? translateR("The Twelve Blessings").map2(translateR("depends on selected tradition"), (base, note) => base + parensIf(note))
                 : translateR("The Twelve Blessings"));
 const renderBlessings = (traditions) => {