@optolith/database-schema 0.111.1 → 0.113.1

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 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.113.1](https://github.com/Optolith/database-schema/compare/v0.113.0...v0.113.1) (2026-10-26)
+
+### Bug Fixes
+
+* **cache:** missing sources for derived select options ([68347f2](https://github.com/Optolith/database-schema/commit/68347f21f6adfc62b4c755b4bc1ad5b8db0a543e))
+
+## [0.113.0](https://github.com/Optolith/database-schema/compare/v0.112.0...v0.113.0) (2026-10-26)
+
+### ⚠ BREAKING CHANGES
+
+* pin enhancement focus rules in settings
+
+### Features
+
+* **cache:** include parent source refs in new applications and uses ([26a0c1a](https://github.com/Optolith/database-schema/commit/26a0c1a959dd7c5ced909cee03a13be67174cc5b))
+* pin enhancement focus rules in settings ([711a7d5](https://github.com/Optolith/database-schema/commit/711a7d5ac1f008e0d684cb4a8e94c7c9209eae8a))
+
+## [0.112.0](https://github.com/Optolith/database-schema/compare/v0.111.1...v0.112.0) (2026-10-24)
+
+### ⚠ BREAKING CHANGES
+
+* custom additional penalties
+* define skill and combat technique rating bonus entries
+* optional armor weight
+
+### Features
+
+* custom additional penalties ([1c56824](https://github.com/Optolith/database-schema/commit/1c56824e11b36a9fdbc3b6cb57588dc0a684358e))
+* define skill and combat technique rating bonus entries ([efe4a54](https://github.com/Optolith/database-schema/commit/efe4a549c01e4ee4ed8710f6447059a5b60cd0b9))
+* optional armor weight ([35729c4](https://github.com/Optolith/database-schema/commit/35729c42a7dd7152be8c3146032a5e42a7ea915a))
+
+### Bug Fixes
+
+* skill descriptions support markdown ([1aeb838](https://github.com/Optolith/database-schema/commit/1aeb838e43bde7a31b8f34ff965b3e06ae3d2c82))
+
 ## [0.111.1](https://github.com/Optolith/database-schema/compare/v0.111.0...v0.111.1) (2026-10-18)
 
 ## [0.111.0](https://github.com/Optolith/database-schema/compare/v0.110.1...v0.111.0) (2026-10-18)

package/gen/types.d.ts

@@ -362,6 +362,7 @@ export type EnumMap = {
   GoblinRitualPerformanceParameters: GoblinRitualPerformanceParameters
   GoblinRitualRangeValue: GoblinRitualRangeValue
   GradientColor: GradientColor
+  HasAdditionalPenalties: HasAdditionalPenalties
   HerbalAidCombatUse: HerbalAidCombatUse
   HerbalPreservationLongevity: HerbalPreservationLongevity
   HerbalPreservationLongevityValue: HerbalPreservationLongevityValue
@@ -645,6 +646,7 @@ export type TypeAliasMap = {
   CursesOptions: CursesOptions
   CustomBannzeichenSuboption: CustomBannzeichenSuboption
   CustomDurationUnit: CustomDurationUnit
+  CustomHasAdditionalPenalties: CustomHasAdditionalPenalties
   CustomMagicalRuneSuboption: CustomMagicalRuneSuboption
   DaggerRitualArcaneEnergyCost: DaggerRitualArcaneEnergyCost
   DefaultEquipmentCategoryTypeRules: DefaultEquipmentCategoryTypeRules
@@ -684,6 +686,7 @@ export type TypeAliasMap = {
   EnergyType: EnergyType
   EnhancementPrerequisite: EnhancementPrerequisite
   EnhancementPrerequisites: EnhancementPrerequisites
+  EnhancementsSettings: EnhancementsSettings
   EquipmentPackageItem: EquipmentPackageItem
   EquipmentPrerequisites: EquipmentPrerequisites
   Errata: Errata
@@ -745,7 +748,6 @@ export type TypeAliasMap = {
   GoblinRitualSustainedCost: GoblinRitualSustainedCost
   GoblinRitualSustainedPerformanceParameters: GoblinRitualSustainedPerformanceParameters
   GroupedCommonProfessions: GroupedCommonProfessions
-  HasAdditionalPenalties: HasAdditionalPenalties
   HeadHitZone: HeadHitZone
   HeadHitZoneCombinationPossibilities: HeadHitZoneCombinationPossibilities
   HerbalAidRecipe: HerbalAidRecipe
@@ -24228,7 +24230,7 @@ export interface Armor {
   /**
    * The weight in kg.
    */
-  weight: Weight
+  weight?: Weight
 
   /**
    * The complexity of crafting the item.
@@ -24363,7 +24365,26 @@ export type Encumbrance = number
 /**
  * Does the armor have additional penalties (MOV -1, INI -1)?
  */
-export type HasAdditionalPenalties = boolean
+export type HasAdditionalPenalties =
+  | {
+    kind: "Standard"
+    Standard: boolean
+  }
+  | {
+    kind: "Custom"
+    Custom: CustomHasAdditionalPenalties
+  }
+
+export type CustomHasAdditionalPenalties = {
+  [derivedCharacteristicId: string]: CustomAdditionalPenalty
+}
+
+export interface CustomAdditionalPenalty {
+  /**
+   * The value of the additional penalty.
+   */
+  value: number
+}
 
 /**
  * The armor type.
@@ -29240,10 +29261,25 @@ export interface Settings {
    */
   styles: StyleSpecialAbilitySettings
 
+  /**
+   * Spell and Liturgical Chant Enhancements are part of focus rules. This type defines which focus rule must be enabled in order to use an enhancement. Essentially, this is a default prerequisite they must meet, but manually inserting them with every enhancement is a lot of work and error-prone. Therefore, in order to use an enhancement, prerequisites for the respective focus rule must be generated for every entry.
+   */
+  enhancements: EnhancementsSettings
+
   /**
    * The publication that extends the description of books with additional information.
    */
   extendedBookDescriptionPublication: Publication_ID
+
+  /**
+   * The entry that grants a bonus of 1 towards the maximum skill rating per selection.
+   */
+  maximumSkillRatingBonusEntry: ActivatableIdentifier
+
+  /**
+   * The entry that grants a bonus of 1 towards the maximum skill rating per selection.
+   */
+  maximumCombatTechniqueRatingBonusEntry: ActivatableIdentifier
 }
 
 /**
@@ -29311,6 +29347,21 @@ export interface StyleSpecialAbilitySettings {
   liturgical: FocusRule_ID
 }
 
+/**
+ * Spell and Liturgical Chant Enhancements are part of focus rules. This type defines which focus rule must be enabled in order to use an enhancement. Essentially, this is a default prerequisite they must meet, but manually inserting them with every enhancement is a lot of work and error-prone. Therefore, in order to use an enhancement, prerequisites for the respective focus rule must be generated for every entry.
+ */
+export interface EnhancementsSettings {
+  /**
+   * The focus rule for spell enhancements.
+   */
+  spell: FocusRule_ID
+
+  /**
+   * The focus rule for liturgical chant enhancements.
+   */
+  liturgicalChant: FocusRule_ID
+}
+
 export interface SexPractice {
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.

package/lib/cache/activatableSelectOptions.js

@@ -102,11 +102,12 @@ const getApValueForSkillish = (config, id, ic) => {
             return assertExhaustive(config);
     }
 };
-const convertSkillApplicationOrUse = (entryId, id, applicationOrUse) => ({
+const convertSkillApplicationOrUse = (entryId, id, applicationOrUse, src) => ({
     id: `${fromUniformCase(entryId)}+${applicationOrUse.id.toFixed()}`,
     content: {
         parent: entryId,
         skills: [id],
+        src,
         translations: applicationOrUse.translations,
     },
 });
@@ -131,7 +132,7 @@ const getSpellworkFilter = (category) => {
             }
         });
 };
-const getDerivedSkillishSelectOptions = (database, entryId, entity, category, options, filter) => {
+const getDerivedSkillishSelectOptions = (database, entryId, entity, category, options, filter, parentSrc) => {
     const { prerequisites } = category;
     const { bindingCost, ap_value } = options;
     const instances = database.getAllInstanceContainersOfEntity(entity);
@@ -150,13 +151,12 @@ const getDerivedSkillishSelectOptions = (database, entryId, entity, category, op
                     name: t10n.name,
                 })),
             },
-            newApplications: category.skill_applications?.map(app => convertSkillApplicationOrUse(entryId, id, app)) ??
-                [],
-            uses: category.skill_uses?.map(use => convertSkillApplicationOrUse(entryId, id, use)) ?? [],
+            newApplications: category.skill_applications?.map(app => convertSkillApplicationOrUse(entryId, id, app, parentSrc)) ?? [],
+            uses: category.skill_uses?.map(use => convertSkillApplicationOrUse(entryId, id, use, parentSrc)) ?? [],
         };
     });
 };
-const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
+const getDerivedSelectOptions = (selectOptionCategory, entryId, database, parentSrc) => {
     switch (selectOptionCategory.kind) {
         case "Blessings":
             return database
@@ -685,15 +685,15 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
                             const matchesIdRequirement = category.Skills.specific === undefined ||
                                 matchesSpecificSkillishIdList(category.Skills.specific, required => required === id);
                             return matchesGroupRequirement && matchesIdRequirement;
-                        });
+                        }, parentSrc);
                     case "Spells":
-                        return getDerivedSkillishSelectOptions(database, entryId, "Spell", category.Spells, selectOptionCategory.Skills, getSpellworkFilter(category.Spells));
+                        return getDerivedSkillishSelectOptions(database, entryId, "Spell", category.Spells, selectOptionCategory.Skills, getSpellworkFilter(category.Spells), parentSrc);
                     case "Rituals":
-                        return getDerivedSkillishSelectOptions(database, entryId, "Ritual", category.Rituals, selectOptionCategory.Skills, getSpellworkFilter(category.Rituals));
+                        return getDerivedSkillishSelectOptions(database, entryId, "Ritual", category.Rituals, selectOptionCategory.Skills, getSpellworkFilter(category.Rituals), parentSrc);
                     case "LiturgicalChants":
-                        return getDerivedSkillishSelectOptions(database, entryId, "LiturgicalChant", category.LiturgicalChants, selectOptionCategory.Skills, getDefaultSkillishFilter(category.LiturgicalChants));
+                        return getDerivedSkillishSelectOptions(database, entryId, "LiturgicalChant", category.LiturgicalChants, selectOptionCategory.Skills, getDefaultSkillishFilter(category.LiturgicalChants), parentSrc);
                     case "Ceremonies":
-                        return getDerivedSkillishSelectOptions(database, entryId, "Ceremony", category.Ceremonies, selectOptionCategory.Skills, getDefaultSkillishFilter(category.Ceremonies));
+                        return getDerivedSkillishSelectOptions(database, entryId, "Ceremony", category.Ceremonies, selectOptionCategory.Skills, getDefaultSkillishFilter(category.Ceremonies), parentSrc);
                     default:
                         return assertExhaustive(category);
                 }
@@ -702,9 +702,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
             return selectOptionCategory.CombatTechniques.categories.flatMap(category => {
                 switch (category.kind) {
                     case "CloseCombatTechniques":
-                        return getDerivedSkillishSelectOptions(database, entryId, "CloseCombatTechnique", category.CloseCombatTechniques, selectOptionCategory.CombatTechniques, getDefaultSkillishFilter(category.CloseCombatTechniques));
+                        return getDerivedSkillishSelectOptions(database, entryId, "CloseCombatTechnique", category.CloseCombatTechniques, selectOptionCategory.CombatTechniques, getDefaultSkillishFilter(category.CloseCombatTechniques), parentSrc);
                     case "RangedCombatTechniques":
-                        return getDerivedSkillishSelectOptions(database, entryId, "RangedCombatTechnique", category.RangedCombatTechniques, selectOptionCategory.CombatTechniques, getDefaultSkillishFilter(category.RangedCombatTechniques));
+                        return getDerivedSkillishSelectOptions(database, entryId, "RangedCombatTechnique", category.RangedCombatTechniques, selectOptionCategory.CombatTechniques, getDefaultSkillishFilter(category.RangedCombatTechniques), parentSrc);
                     default:
                         return assertExhaustive(category);
                 }
@@ -787,14 +787,14 @@ const getExplicitSelectOptions = (id, database) => database
     newApplications: [], // database.getAllChildInstanceContainersForParent("NewSkillApplication", Case("GeneralSelectOption", id)), // prevent duplicates as these can already be queried from the database
     uses: [], // database.getAllChildInstanceContainersForParent("SkillUse", Case("GeneralSelectOption", id)), // prevent duplicates as these can already be queried from the database
 }));
-const getSelectOptions = (selectOptions, id, database) => [
+const getSelectOptions = (selectOptions, id, database, parentSrc) => [
     ...(selectOptions.derived === undefined
         ? []
-        : getDerivedSelectOptions(selectOptions.derived, id, database)),
+        : getDerivedSelectOptions(selectOptions.derived, id, database, parentSrc)),
     ...getExplicitSelectOptions(id, database),
 ];
 const getSelectOptionsForResults = (database, entity, results) => results.reduce((acc, { id, content }) => {
-    const options = getSelectOptions(content.select_options ?? {}, Case(entity, id), database);
+    const options = getSelectOptions(content.select_options ?? {}, Case(entity, id), database, content.src);
     if (options.length > 0) {
         acc[id] = options;
     }

package/lib/cache/newApplicationsAndUses.d.ts

@@ -1,16 +1,18 @@
-import type { ActivatableIdentifier, NewSkillApplication, NewSkillApplicationOrUseParentIdentifier, Skill_ID, SkillUse } from "../../gen/types.js";
+import type { ActivatableIdentifier, NewSkillApplication, NewSkillApplicationOrUseParentIdentifier, PublicationRefs, Skill_ID, SkillUse } from "../../gen/types.js";
 import type { ActivatableSelectOptionsCache } from "./activatableSelectOptions.ts";
 import type { CacheBuilder } from "./internal.ts";
 export type ResolvedNewSkillApplication = {
     id: string;
     content: Omit<NewSkillApplication, "parent"> & {
         parent: NewSkillApplicationOrUseParentIdentifier | ActivatableIdentifier;
+        src: PublicationRefs | undefined;
     };
 };
 export type ResolvedSkillUse = {
     id: string;
     content: Omit<SkillUse, "parent"> & {
         parent: NewSkillApplicationOrUseParentIdentifier | ActivatableIdentifier;
+        src: PublicationRefs | undefined;
     };
 };
 export type NewApplicationsAndUsesCache = {

package/lib/cache/newApplicationsAndUses.js

@@ -1,15 +1,23 @@
-const groupByAffectedSkill = (entries, prev = {}) => entries.reduce((acc, entry) => entry.content.skills.reduce((acc1, skillId) => {
+const groupByAffectedSkill = (database, entries, prev = {}) => entries
+    .map(entry => ({
+    ...entry,
+    content: {
+        ...entry.content,
+        src: database.getInstanceOfEntityById(entry.content.parent)?.src,
+    },
+}))
+    .reduce((acc, entry) => entry.content.skills.reduce((acc1, skillId) => {
     acc1[skillId] = [...(acc1[skillId] ?? []), entry];
     return acc1;
 }, acc), prev);
-const addGeneratedEntries = (generatedSelectOptions, prev) => Object.values(generatedSelectOptions).reduce((acc, byInstance) => Object.values(byInstance).reduce((acc1, resolvedSelectOptions) => resolvedSelectOptions.reduce((acc2, selectOption) => ({
-    newApplications: groupByAffectedSkill(selectOption.newApplications, acc2.newApplications),
-    uses: groupByAffectedSkill(selectOption.uses, acc2.uses),
+const addGeneratedEntries = (database, generatedSelectOptions, prev) => Object.values(generatedSelectOptions).reduce((acc, byInstance) => Object.values(byInstance).reduce((acc1, resolvedSelectOptions) => resolvedSelectOptions.reduce((acc2, selectOption) => ({
+    newApplications: groupByAffectedSkill(database, selectOption.newApplications, acc2.newApplications),
+    uses: groupByAffectedSkill(database, selectOption.uses, acc2.uses),
 }), acc1), acc), prev);
 export const buildNewApplicationsAndUsesCache = (database, _idMap, generatedSelectOptions) => {
     const cache = {
-        newApplications: groupByAffectedSkill(database.getAllInstanceContainersOfEntity("NewSkillApplication")),
-        uses: groupByAffectedSkill(database.getAllInstanceContainersOfEntity("SkillUse")),
+        newApplications: groupByAffectedSkill(database, database.getAllInstanceContainersOfEntity("NewSkillApplication")),
+        uses: groupByAffectedSkill(database, database.getAllInstanceContainersOfEntity("SkillUse")),
     };
-    return addGeneratedEntries(generatedSelectOptions, cache);
+    return addGeneratedEntries(database, generatedSelectOptions, cache);
 };

package/lib/types/Settings.d.ts

@@ -186,5 +186,127 @@ export declare const Settings: DB.SingletonEntity<"Settings", {
         magic: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         liturgical: DB.MemberDecl<DB.ReferenceIdentifier, true>;
     }>, []>>, true>;
+    enhancements: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementsSettings", DB.Object<{
+        spell: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        liturgicalChant: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    }>, []>>, true>;
     extendedBookDescriptionPublication: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    maximumSkillRatingBonusEntry: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
+        Adoruzepterzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        AttireEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Beutelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        BowlEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        CauldronEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        ChronicleEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        DaggerRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+        FoolsHatEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Haubenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Hauerkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        InstrumentEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Keulenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Krallenkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Kristallkugelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        OrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        RingEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Schweinetrommelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        SickleRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+        SpellSwordEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        StaffEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        ToyEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Trinkhornzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AncestorGlyph: DB.EnumCase<DB.ReferenceIdentifier>;
+        BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        BrawlingSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CeremonialItemSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CombatStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CommandSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FamiliarSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FatePointSexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FatePointSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        GeneralSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        KarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        LiturgicalStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        LycantropicGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalSign: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        PactGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        ProtectiveWardingCircleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        Sermon: DB.EnumCase<DB.ReferenceIdentifier>;
+        SexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        SikaryanDrainSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        SkillStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        VampiricGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        Vision: DB.EnumCase<DB.ReferenceIdentifier>;
+        Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+        Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, true>;
+    maximumCombatTechniqueRatingBonusEntry: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
+        Adoruzepterzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        AttireEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Beutelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        BowlEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        CauldronEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        ChronicleEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        DaggerRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+        FoolsHatEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Haubenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Hauerkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        InstrumentEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Keulenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Krallenkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Kristallkugelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        OrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        RingEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Schweinetrommelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        SickleRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+        SpellSwordEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        StaffEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        ToyEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Trinkhornzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AncestorGlyph: DB.EnumCase<DB.ReferenceIdentifier>;
+        BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        BrawlingSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CeremonialItemSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CombatStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CommandSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FamiliarSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FatePointSexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FatePointSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        GeneralSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        KarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        LiturgicalStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        LycantropicGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalSign: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        PactGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        ProtectiveWardingCircleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        Sermon: DB.EnumCase<DB.ReferenceIdentifier>;
+        SexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        SikaryanDrainSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        SkillStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        VampiricGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        Vision: DB.EnumCase<DB.ReferenceIdentifier>;
+        Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+        Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, true>;
 }>;

package/lib/types/Settings.js

@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 import { AdvantageIdentifier, DerivedCharacteristicIdentifier, ExperienceLevelIdentifier, FocusRuleIdentifier, PublicationIdentifier, } from "./_Identifier.js";
-import { SpecialAbilityIdentifier } from "./_IdentifierGroup.js";
+import { ActivatableIdentifier, SpecialAbilityIdentifier } from "./_IdentifierGroup.js";
 export const Settings = DB.SingletonEntity(import.meta.url, {
     name: "Settings",
     type: () => DB.Object({
@@ -27,10 +27,22 @@ export const Settings = DB.SingletonEntity(import.meta.url, {
             comment: StyleSpecialAbilitySettings.comment,
             type: DB.IncludeIdentifier(StyleSpecialAbilitySettings),
         }),
+        enhancements: DB.Required({
+            comment: EnhancementsSettings.comment,
+            type: DB.IncludeIdentifier(EnhancementsSettings),
+        }),
         extendedBookDescriptionPublication: DB.Required({
             comment: "The publication that extends the description of books with additional information.",
             type: PublicationIdentifier(),
         }),
+        maximumSkillRatingBonusEntry: DB.Required({
+            comment: "The entry that grants a bonus of 1 towards the maximum skill rating per selection.",
+            type: DB.IncludeIdentifier(ActivatableIdentifier),
+        }),
+        maximumCombatTechniqueRatingBonusEntry: DB.Required({
+            comment: "The entry that grants a bonus of 1 towards the maximum skill rating per selection.",
+            type: DB.IncludeIdentifier(ActivatableIdentifier),
+        }),
     }),
 });
 const SupernaturalBaseAdvantageSettings = DB.TypeAlias(import.meta.url, {
@@ -95,3 +107,17 @@ const StyleSpecialAbilitySettings = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
+const EnhancementsSettings = DB.TypeAlias(import.meta.url, {
+    name: "EnhancementsSettings",
+    comment: "Spell and Liturgical Chant Enhancements are part of focus rules. This type defines which focus rule must be enabled in order to use an enhancement. Essentially, this is a default prerequisite they must meet, but manually inserting them with every enhancement is a lot of work and error-prone. Therefore, in order to use an enhancement, prerequisites for the respective focus rule must be generated for every entry.",
+    type: () => DB.Object({
+        spell: DB.Required({
+            comment: "The focus rule for spell enhancements.",
+            type: FocusRuleIdentifier(),
+        }),
+        liturgicalChant: DB.Required({
+            comment: "The focus rule for liturgical chant enhancements.",
+            type: FocusRuleIdentifier(),
+        }),
+    }),
+});

package/lib/types/Skill.js

@@ -48,23 +48,23 @@ export const Skill = DB.Entity(import.meta.url, {
             }),
             tools: DB.Optional({
                 comment: "Mentions any tools from the equipment list that are necessary to employ the skill.",
-                type: DB.String({ minLength: 1 }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             quality: DB.Required({
                 comment: "Gives examples of the effects that various QL might provide.",
-                type: DB.String({ minLength: 1 }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             failed: DB.Required({
                 comment: "Lists examples of results for a failed check.",
-                type: DB.String({ minLength: 1 }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             critical: DB.Required({
                 comment: "Lists examples of results for a critical success.",
-                type: DB.String({ minLength: 1 }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             botch: DB.Required({
                 comment: "Lists examples of results for botches.",
-                type: DB.String({ minLength: 1 }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

package/lib/types/equipment/item/Armor.d.ts

@@ -22,7 +22,7 @@ export declare const Armor: DB.Entity<"Armor", {
             }>, false>;
         }>, []>>>;
     }, []>>, true>;
-    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, true>;
+    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, false>;
     complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorComplexity", {
         Primitive: DB.EnumCase<null>;
         Simple: DB.EnumCase<null>;
@@ -98,7 +98,12 @@ export declare const Armor: DB.Entity<"Armor", {
     }, []>>, false>;
     protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
     encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-    has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+    has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+        Standard: DB.EnumCase<DB.Boolean>;
+        Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+    }, []>>, true>;
     armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
         Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
             sturdinessRating: DB.MemberDecl<DB.Integer, true>;
@@ -300,7 +305,12 @@ export declare const Armor: DB.Entity<"Armor", {
 export declare const SecondaryArmor: DB.TypeAlias<"SecondaryArmor", DB.Object<{
     protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
     encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-    has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+    has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+        Standard: DB.EnumCase<DB.Boolean>;
+        Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+    }, []>>, true>;
     armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
         Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
             sturdinessRating: DB.MemberDecl<DB.Integer, true>;
@@ -378,4 +388,9 @@ export declare const SecondaryArmor: DB.TypeAlias<"SecondaryArmor", DB.Object<{
 }>, []>;
 export declare const Protection: DB.TypeAlias<"Protection", DB.Integer, []>;
 export declare const Encumbrance: DB.TypeAlias<"Encumbrance", DB.Integer, []>;
-export declare const HasAdditionalPenalties: DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>;
+export declare const HasAdditionalPenalties: DB.Enum<"HasAdditionalPenalties", {
+    Standard: DB.EnumCase<DB.Boolean>;
+    Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+        value: DB.MemberDecl<DB.Integer, true>;
+    }>, []>>>;
+}, []>;

package/lib/types/equipment/item/Armor.js

@@ -2,6 +2,7 @@ import { isNotNullish } from "@elyukai/utils/nullable";
 import * as DB from "tsondb/schema/dsl";
 import { ArmorIdentifier } from "../../_Identifier.js";
 import { EquipmentPrerequisites } from "../../_Prerequisite.js";
+import { DerivedCharacteristic } from "../../DerivedCharacteristic.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
@@ -14,7 +15,7 @@ export const Armor = DB.Entity(import.meta.url, {
             comment: "The cost in silverthalers.",
             type: DB.IncludeIdentifier(Cost),
         }),
-        weight: DB.Required({
+        weight: DB.Optional({
             comment: "The weight in kg.",
             type: DB.IncludeIdentifier(Weight),
         }),
@@ -234,10 +235,28 @@ export const Encumbrance = DB.TypeAlias(import.meta.url, {
     comment: "The ENC value.",
     type: () => DB.Integer({ minimum: 0 }),
 });
-export const HasAdditionalPenalties = DB.TypeAlias(import.meta.url, {
+export const HasAdditionalPenalties = DB.Enum(import.meta.url, {
     name: "HasAdditionalPenalties",
     comment: "Does the armor have additional penalties (MOV -1, INI -1)?",
-    type: () => DB.Boolean(),
+    values: () => ({
+        Standard: DB.EnumCase({ type: DB.Boolean() }),
+        Custom: DB.EnumCase({ type: DB.IncludeIdentifier(CustomHasAdditionalPenalties) }),
+    }),
+});
+const CustomHasAdditionalPenalties = DB.TypeAlias(import.meta.url, {
+    name: "CustomHasAdditionalPenalties",
+    type: () => DB.NestedEntityMap({
+        name: "CustomAdditionalPenalty",
+        namePlural: "CustomAdditionalPenalties",
+        secondaryEntity: DerivedCharacteristic,
+        type: DB.Object({
+            value: DB.Required({
+                comment: "The value of the additional penalty.",
+                type: DB.Integer(),
+            }),
+        }),
+        minProperties: 1,
+    }),
 });
 const HitZone = DB.Enum(import.meta.url, {
     name: "HitZone",

package/lib/types/equipment/item/ArmorAccessory.d.ts

@@ -194,7 +194,12 @@ export declare const ArmorAccessory: DB.Entity<"ArmorAccessory", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/BandageOrRemedy.d.ts

@@ -194,7 +194,12 @@ export declare const BandageOrRemedy: DB.Entity<"BandageOrRemedy", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/CeremonialItem.d.ts

@@ -199,7 +199,12 @@ export declare const CeremonialItem: DB.Entity<"CeremonialItem", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/Clothes.d.ts

@@ -194,7 +194,12 @@ export declare const Clothes: DB.Entity<"Clothes", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/Container.d.ts

@@ -194,7 +194,12 @@ export declare const Container: DB.Entity<"Container", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/EquipmentOfBlessedOnes.d.ts

@@ -125,7 +125,12 @@ export declare const EquipmentOfBlessedOnes: DB.Entity<"EquipmentOfBlessedOnes",
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/IlluminationLightSource.d.ts

@@ -203,7 +203,12 @@ export declare const IlluminationLightSource: DB.Entity<"IlluminationLightSource
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/IlluminationRefillOrSupply.d.ts

@@ -194,7 +194,12 @@ export declare const IlluminationRefillOrSupply: DB.Entity<"IlluminationRefillOr
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/Item.d.ts

@@ -159,7 +159,12 @@ export declare const Item: DB.Entity<"Item", {
     armorUse: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
         protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
         encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-        has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+        has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+            Standard: DB.EnumCase<DB.Boolean>;
+            Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                value: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+        }, []>>, true>;
         armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
             Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                 sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/Liebesspielzeug.d.ts

@@ -194,7 +194,12 @@ export declare const Liebesspielzeug: DB.Entity<"Liebesspielzeug", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/LuxuryGood.d.ts

@@ -194,7 +194,12 @@ export declare const LuxuryGood: DB.Entity<"LuxuryGood", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/MagicalArtifact.d.ts

@@ -194,7 +194,12 @@ export declare const MagicalArtifact: DB.Entity<"MagicalArtifact", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/MusicalInstrument.d.ts

@@ -194,7 +194,12 @@ export declare const MusicalInstrument: DB.Entity<"MusicalInstrument", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/OrienteeringAid.d.ts

@@ -193,7 +193,12 @@ export declare const OrienteeringAid: import("tsondb/schema/dsl").Entity<string,
         Armor: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"SecondaryArmor", import("tsondb/schema/dsl").Object<{
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
-            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
+            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HasAdditionalPenalties", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").Boolean>;
+                Custom: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"CustomHasAdditionalPenalties", import("tsondb/schema/dsl").NestedEntityMap<string, {
+                    value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
                 Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
                     sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;

package/lib/types/equipment/item/RopeOrChain.d.ts

@@ -193,7 +193,12 @@ export declare const RopeOrChain: import("tsondb/schema/dsl").Entity<string, {
         Armor: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"SecondaryArmor", import("tsondb/schema/dsl").Object<{
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
-            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
+            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HasAdditionalPenalties", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").Boolean>;
+                Custom: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"CustomHasAdditionalPenalties", import("tsondb/schema/dsl").NestedEntityMap<string, {
+                    value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
                 Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
                     sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;

package/lib/types/equipment/item/Stationery.d.ts

@@ -193,7 +193,12 @@ export declare const Stationery: import("tsondb/schema/dsl").Entity<string, {
         Armor: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"SecondaryArmor", import("tsondb/schema/dsl").Object<{
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
-            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
+            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HasAdditionalPenalties", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").Boolean>;
+                Custom: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"CustomHasAdditionalPenalties", import("tsondb/schema/dsl").NestedEntityMap<string, {
+                    value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
                 Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
                     sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;

package/lib/types/equipment/item/ThievesTool.d.ts

@@ -193,7 +193,12 @@ export declare const ThievesTool: import("tsondb/schema/dsl").Entity<string, {
         Armor: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"SecondaryArmor", import("tsondb/schema/dsl").Object<{
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
-            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
+            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HasAdditionalPenalties", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").Boolean>;
+                Custom: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"CustomHasAdditionalPenalties", import("tsondb/schema/dsl").NestedEntityMap<string, {
+                    value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
                 Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
                     sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;

package/lib/types/equipment/item/TravelGearOrTool.d.ts

@@ -194,7 +194,12 @@ export declare const TravelGearOrTool: DB.Entity<"TravelGearOrTool", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/WeaponAccessory.d.ts

@@ -194,7 +194,12 @@ export declare const WeaponAccessory: DB.Entity<"WeaponAccessory", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/lib/types/equipment/item/_Item.d.ts

@@ -194,7 +194,12 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;
@@ -450,7 +455,12 @@ export declare const CombatUse: DB.Enum<"CombatUse", {
     Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
         protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
         encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
-        has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+        has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+            Standard: DB.EnumCase<DB.Boolean>;
+            Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                value: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+        }, []>>, true>;
         armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
             Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                 sturdinessRating: DB.MemberDecl<DB.Integer, true>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.111.1",
+  "version": "0.113.1",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",