@optolith/database-schema 0.63.1 → 0.64.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 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.64.0](https://github.com/Optolith/database-schema/compare/v0.63.1...v0.64.0) (2026-09-23)
+
+### ⚠ BREAKING CHANGES
+
+* blessed rank/title flags
+* combat techniques by AP profession option
+* optional starting age
+* spellworks by AP profession option
+
+### Features
+
+* blessed rank/title flags ([eec7536](https://github.com/Optolith/database-schema/commit/eec75368241160486c0a7affccf27093749d0e23)), closes [#189](https://github.com/Optolith/database-schema/issues/189)
+* ceremonial item special ability groups ([3989234](https://github.com/Optolith/database-schema/commit/3989234c9a62133317a2ef8d38de8ace7c7430e0))
+* combat techniques by AP profession option ([b57cb67](https://github.com/Optolith/database-schema/commit/b57cb67163e90694595e4a9aeb152ef0495cd33e)), closes [#187](https://github.com/Optolith/database-schema/issues/187)
+* spellworks by AP profession option ([3ff20c7](https://github.com/Optolith/database-schema/commit/3ff20c714cb99aaca4783a7e4e2446f5226943f9)), closes [#188](https://github.com/Optolith/database-schema/issues/188)
+
+### Bug Fixes
+
+* optional starting age ([f63a882](https://github.com/Optolith/database-schema/commit/f63a882d2a332630600939577e40c22012f91b95))
 ## [0.63.1](https://github.com/Optolith/database-schema/compare/v0.63.0...v0.63.1) (2026-09-22)
 
 ### Features

package/gen/types.d.ts

@@ -41,6 +41,7 @@ export type EntityMap = {
   CauldronEnchantment: CauldronEnchantment
   CeremonialItem: CeremonialItem
   CeremonialItemSpecialAbility: CeremonialItemSpecialAbility
+  CeremonialItemSpecialAbilityGroup: CeremonialItemSpecialAbilityGroup
   Ceremony: Ceremony
   ChronicleEnchantment: ChronicleEnchantment
   CloseCombatTechnique: CloseCombatTechnique
@@ -561,6 +562,7 @@ export type TypeAliasMap = {
   CombatAnimalPower: CombatAnimalPower
   CombatTechniqueAdjustment: CombatTechniqueAdjustment
   CombatTechniqueRating: CombatTechniqueRating
+  CombatTechniquesForAdventurePointsOption: CombatTechniquesForAdventurePointsOption
   CombatTechniquesOptions: CombatTechniquesOptions
   CombatTechniquesSelectOptionCategory: CombatTechniquesSelectOptionCategory
   CommonCantripNotes: CommonCantripNotes
@@ -917,6 +919,7 @@ export type TypeAliasMap = {
   SpellworkAdjustmentWithBase: SpellworkAdjustmentWithBase
   SpellworkChange: SpellworkChange
   SpellworkPrerequisites: SpellworkPrerequisites
+  SpellworksOptions: SpellworksOptions
   StandaloneCostMap: StandaloneCostMap
   StatePrerequisite: StatePrerequisite
   StructurePoints: StructurePoints
@@ -2458,6 +2461,8 @@ export interface Locale {
     "Magical Title": string
     "Magical Honor": string
     "Magical Punishment": string
+    "Blessed Rank": string
+    "Blessed Title": string
     ".input {$ord :number} {{{$ord}. attack}}": string & { __params: { "ord": number } }
     ".input {$ord :number} {{{$ord}. throw}}": string & { __params: { "ord": number } }
     "depending on the level of the special ability {$name}": string & { __params: { "name": StringableTranslationParameter } }
@@ -2694,6 +2699,8 @@ export interface Locale {
     "maximum SR per skill: {$maxSR}": string & { __params: { "maxSR": StringableTranslationParameter } }
     "no AP to improve other {$skillsOfGroup}": string & { __params: { "skillsOfGroup": StringableTranslationParameter } }
     ".input {$count :number} {{{$count} cantrips}}": string & { __params: { "count": number } }
+    ".input {$apValue :number} {{{$apValue} AP to distribute among the following combat techniques: {$list}}}": string & { __params: { "apValue": number; "list": StringableTranslationParameter } }
+    ".input {$count :number} {{{$count} more spellworks totaling {$apValue} AP}}": string & { __params: { "count": number; "apValue": StringableTranslationParameter } }
     "{$count} from the following list": string & { __params: { "count": StringableTranslationParameter } }
     "The Twelve Blessings": string
     "except for {$list :list type=conjunction}": string & { __params: { "list": StringableTranslationParameter } }
@@ -3176,6 +3183,12 @@ export type AdvantageDisadvantageSubtype =
   | {
     kind: "MagicalPunishment"
   }
+  | {
+    kind: "BlessedRank"
+  }
+  | {
+    kind: "BlessedTitle"
+  }
 
 export interface GeneralSelectOption {
   /**
@@ -4582,7 +4595,7 @@ export interface Race {
   /**
    * Defines the starting ages for the race. It depends on the selected experience level.
    */
-  starting_age: {
+  starting_age?: {
     [experienceLevelId: string]: StartingAgeConfigForExperienceLevel
   }
 
@@ -9989,9 +10002,11 @@ export interface ProfessionVariantPackageOptions {
   skill_specialization?: VariantOptionAction<SkillSpecializationOptions>
   languages_scripts?: VariantOptionAction<LanguagesScriptsOptions>
   combat_techniques?: VariantOptionAction<CombatTechniquesOptions>
+  combatTechniquesForAdventurePoints?: VariantOptionAction<CombatTechniquesForAdventurePointsOption>
   cantrips?: VariantOptionAction<CantripsOptions>
   curses?: VariantOptionAction<CursesOptions>
   skills?: VariantOptionAction<SkillsOptions>
+  spellworks?: VariantOptionAction<SpellworksOptions>
   liturgies?: VariantOptionAction<LiturgiesOptions>
 }
 
@@ -10071,6 +10086,21 @@ export interface RatingForCombatTechniquesNumber {
   rating_modifier: number
 }
 
+/**
+ * Distribe a set amount of Adventure Points among a given set of combat techniques.
+ */
+export interface CombatTechniquesForAdventurePointsOption {
+  /**
+   * The AP value to distribute.
+   */
+  apValue: number
+
+  /**
+   * The list of combat techniques to distribute to.
+   */
+  options: CombatTechniqueIdentifier[]
+}
+
 /**
  * Select one or more cantrips you receive.
  */
@@ -10303,6 +10333,21 @@ export interface SkillsOptions {
   ap_value: number
 }
 
+/**
+ * Buy a set number of spells and rituals for a specific amount of AP.
+ */
+export interface SpellworksOptions {
+  /**
+   * The number of spells and rituals to select.
+   */
+  number: number
+
+  /**
+   * The AP value you can buy spells and rituals for.
+   */
+  apValue: number
+}
+
 /**
  * Buy liturgical chants and ceremonies for a specific amount of AP.
  */
@@ -13002,6 +13047,8 @@ export interface BrewTranslation {
 }
 
 export interface CeremonialItemSpecialAbility {
+  associatedItem?: CeremonialItemSpecialAbilityGroup_ID
+
   /**
    * Number of available levels.
    */
@@ -13091,6 +13138,32 @@ export interface CeremonialItemSpecialAbilityTranslation {
   errata?: Errata
 }
 
+export interface CeremonialItemSpecialAbilityGroup {
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: CeremonialItemSpecialAbilityGroupTranslation
+  }
+}
+
+/**
+ * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
+ */
+export type CeremonialItemSpecialAbilityGroup_ID = string
+
+export interface CeremonialItemSpecialAbilityGroupTranslation {
+  /**
+   * The name of the ceremonial item. This should be the heading used in the respective publication.
+   */
+  name: string
+
+  /**
+   * The name of the ceremonial item for sorting purposes, if different from the actual name.
+   */
+  nameForSorting: string
+}
+
 export interface ChronicleEnchantment {
   /**
    * Number of available levels.
@@ -20622,9 +20695,11 @@ export interface ProfessionPackageOptions {
   skill_specialization?: SkillSpecializationOptions
   languages_scripts?: LanguagesScriptsOptions
   combat_techniques?: CombatTechniquesOptions
+  combatTechniquesForAdventurePoints?: CombatTechniquesForAdventurePointsOption
   cantrips?: CantripsOptions
   curses?: CursesOptions
   skills?: SkillsOptions
+  spellworks?: SpellworksOptions
   liturgies?: LiturgiesOptions
 }
 

package/lib/main.js

@@ -40,6 +40,7 @@ export const schema = new Schema([
     Types.CauldronEnchantment,
     Types.CeremonialItem,
     Types.CeremonialItemSpecialAbility,
+    Types.CeremonialItemSpecialAbilityGroup,
     Types.Ceremony,
     Types.ChronicleEnchantment,
     Types.CloseCombatTechnique,

package/lib/types/Advantage.d.ts

@@ -6,6 +6,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
         MagicalTitle: DB.EnumCase<null>;
         MagicalHonor: DB.EnumCase<null>;
         MagicalPunishment: DB.EnumCase<null>;
+        BlessedRank: DB.EnumCase<null>;
+        BlessedTitle: DB.EnumCase<null>;
     }, []>>, false>;
     nameBuilderRules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableNameBuilderRules", DB.Object<{
         levelPlacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableNameLevelPlacement", {

package/lib/types/Disadvantage.d.ts

@@ -6,6 +6,8 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
         MagicalTitle: DB.EnumCase<null>;
         MagicalHonor: DB.EnumCase<null>;
         MagicalPunishment: DB.EnumCase<null>;
+        BlessedRank: DB.EnumCase<null>;
+        BlessedTitle: DB.EnumCase<null>;
     }, []>>, false>;
     nameBuilderRules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableNameBuilderRules", DB.Object<{
         levelPlacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableNameLevelPlacement", {

package/lib/types/Locale.d.ts

@@ -1380,6 +1380,8 @@ export declare const Locale: DB.Entity<"Locale", {
         "Magical Title": null;
         "Magical Honor": null;
         "Magical Punishment": null;
+        "Blessed Rank": null;
+        "Blessed Title": null;
         ".input {$ord :number} {{{$ord}. attack}}": null;
         ".input {$ord :number} {{{$ord}. throw}}": null;
         "depending on the level of the special ability {$name}": null;
@@ -1616,6 +1618,8 @@ export declare const Locale: DB.Entity<"Locale", {
         "maximum SR per skill: {$maxSR}": null;
         "no AP to improve other {$skillsOfGroup}": null;
         ".input {$count :number} {{{$count} cantrips}}": null;
+        ".input {$apValue :number} {{{$apValue} AP to distribute among the following combat techniques: {$list}}}": null;
+        ".input {$count :number} {{{$count} more spellworks totaling {$apValue} AP}}": null;
         "{$count} from the following list": null;
         "The Twelve Blessings": null;
         "except for {$list :list type=conjunction}": null;

package/lib/types/Locale.js

@@ -1416,6 +1416,8 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Magical Title": null,
                 "Magical Honor": null,
                 "Magical Punishment": null,
+                "Blessed Rank": null,
+                "Blessed Title": null,
                 // combat special ability -- penalty
                 ".input {$ord :number} {{{$ord}. attack}}": null,
                 ".input {$ord :number} {{{$ord}. throw}}": null,
@@ -1667,6 +1669,8 @@ export const Locale = DB.Entity(import.meta.url, {
                 "maximum SR per skill: {$maxSR}": null,
                 "no AP to improve other {$skillsOfGroup}": null,
                 ".input {$count :number} {{{$count} cantrips}}": null,
+                ".input {$apValue :number} {{{$apValue} AP to distribute among the following combat techniques: {$list}}}": null,
+                ".input {$count :number} {{{$count} more spellworks totaling {$apValue} AP}}": null,
                 "{$count} from the following list": null,
                 "The Twelve Blessings": null,
                 "except for {$list :list type=conjunction}": null,

package/lib/types/Profession.d.ts

@@ -62,6 +62,13 @@ export declare const Profession: DB.Entity<"Profession", {
                         RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
                     }, []>>>, true>;
                 }>, []>>, false>;
+                combatTechniquesForAdventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CombatTechniquesForAdventurePointsOption", DB.Object<{
+                    apValue: DB.MemberDecl<DB.Integer, true>;
+                    options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CombatTechniqueIdentifier", {
+                        CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                        RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                    }, []>>>, true>;
+                }>, []>>, false>;
                 cantrips: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CantripsOptions", DB.Object<{
                     number: DB.MemberDecl<DB.Integer, true>;
                     options: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
@@ -74,6 +81,10 @@ export declare const Profession: DB.Entity<"Profession", {
                     specific: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                     ap_value: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>, false>;
+                spellworks: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworksOptions", DB.Object<{
+                    number: DB.MemberDecl<DB.Integer, true>;
+                    apValue: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>, false>;
                 liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
                     ap_value: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>, false>;
@@ -314,6 +325,10 @@ export declare const Profession: DB.Entity<"Profession", {
                         Remove: DB.EnumCase<null>;
                         Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
                     }, [T: DB.Param<"T", DB.Type>]>>, false>;
+                    combatTechniquesForAdventurePoints: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
+                        Remove: DB.EnumCase<null>;
+                        Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                    }, [T: DB.Param<"T", DB.Type>]>>, false>;
                     cantrips: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
                         Remove: DB.EnumCase<null>;
                         Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
@@ -326,6 +341,10 @@ export declare const Profession: DB.Entity<"Profession", {
                         Remove: DB.EnumCase<null>;
                         Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
                     }, [T: DB.Param<"T", DB.Type>]>>, false>;
+                    spellworks: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
+                        Remove: DB.EnumCase<null>;
+                        Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                    }, [T: DB.Param<"T", DB.Type>]>>, false>;
                     liturgies: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
                         Remove: DB.EnumCase<null>;
                         Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
@@ -829,6 +848,13 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                     RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
                 }, []>>>, true>;
             }>, []>>, false>;
+            combatTechniquesForAdventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CombatTechniquesForAdventurePointsOption", DB.Object<{
+                apValue: DB.MemberDecl<DB.Integer, true>;
+                options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CombatTechniqueIdentifier", {
+                    CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                    RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>>, true>;
+            }>, []>>, false>;
             cantrips: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CantripsOptions", DB.Object<{
                 number: DB.MemberDecl<DB.Integer, true>;
                 options: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
@@ -841,6 +867,10 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                 specific: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                 ap_value: DB.MemberDecl<DB.Integer, true>;
             }>, []>>, false>;
+            spellworks: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworksOptions", DB.Object<{
+                number: DB.MemberDecl<DB.Integer, true>;
+                apValue: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>, false>;
             liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
                 ap_value: DB.MemberDecl<DB.Integer, true>;
             }>, []>>, false>;
@@ -1081,6 +1111,10 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                     Remove: DB.EnumCase<null>;
                     Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
                 }, [T: DB.Param<"T", DB.Type>]>>, false>;
+                combatTechniquesForAdventurePoints: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
+                    Remove: DB.EnumCase<null>;
+                    Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                }, [T: DB.Param<"T", DB.Type>]>>, false>;
                 cantrips: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
                     Remove: DB.EnumCase<null>;
                     Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
@@ -1093,6 +1127,10 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                     Remove: DB.EnumCase<null>;
                     Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
                 }, [T: DB.Param<"T", DB.Type>]>>, false>;
+                spellworks: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
+                    Remove: DB.EnumCase<null>;
+                    Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                }, [T: DB.Param<"T", DB.Type>]>>, false>;
                 liturgies: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
                     Remove: DB.EnumCase<null>;
                     Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
@@ -1588,6 +1626,13 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
                 RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
             }, []>>>, true>;
         }>, []>>, false>;
+        combatTechniquesForAdventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CombatTechniquesForAdventurePointsOption", DB.Object<{
+            apValue: DB.MemberDecl<DB.Integer, true>;
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CombatTechniqueIdentifier", {
+                CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>>, true>;
+        }>, []>>, false>;
         cantrips: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CantripsOptions", DB.Object<{
             number: DB.MemberDecl<DB.Integer, true>;
             options: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
@@ -1600,6 +1645,10 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
             specific: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             ap_value: DB.MemberDecl<DB.Integer, true>;
         }>, []>>, false>;
+        spellworks: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworksOptions", DB.Object<{
+            number: DB.MemberDecl<DB.Integer, true>;
+            apValue: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>, false>;
         liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
         }>, []>>, false>;
@@ -1840,6 +1889,10 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
                 Remove: DB.EnumCase<null>;
                 Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
             }, [T: DB.Param<"T", DB.Type>]>>, false>;
+            combatTechniquesForAdventurePoints: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
+                Remove: DB.EnumCase<null>;
+                Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>, false>;
             cantrips: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
                 Remove: DB.EnumCase<null>;
                 Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
@@ -1852,6 +1905,10 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
                 Remove: DB.EnumCase<null>;
                 Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
             }, [T: DB.Param<"T", DB.Type>]>>, false>;
+            spellworks: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
+                Remove: DB.EnumCase<null>;
+                Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>, false>;
             liturgies: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
                 Remove: DB.EnumCase<null>;
                 Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
@@ -2108,6 +2165,10 @@ export declare const ProfessionVariant: DB.Entity<"ProfessionVariant", {
             Remove: DB.EnumCase<null>;
             Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
         }, [T: DB.Param<"T", DB.Type>]>>, false>;
+        combatTechniquesForAdventurePoints: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
+            Remove: DB.EnumCase<null>;
+            Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        }, [T: DB.Param<"T", DB.Type>]>>, false>;
         cantrips: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
             Remove: DB.EnumCase<null>;
             Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
@@ -2120,6 +2181,10 @@ export declare const ProfessionVariant: DB.Entity<"ProfessionVariant", {
             Remove: DB.EnumCase<null>;
             Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
         }, [T: DB.Param<"T", DB.Type>]>>, false>;
+        spellworks: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
+            Remove: DB.EnumCase<null>;
+            Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        }, [T: DB.Param<"T", DB.Type>]>>, false>;
         liturgies: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
             Remove: DB.EnumCase<null>;
             Override: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;

package/lib/types/Profession.js

@@ -438,6 +438,9 @@ const ProfessionPackageOptions = DB.TypeAlias(import.meta.url, {
         combat_techniques: DB.Optional({
             type: DB.IncludeIdentifier(CombatTechniquesOptions),
         }),
+        combatTechniquesForAdventurePoints: DB.Optional({
+            type: DB.IncludeIdentifier(CombatTechniquesForAdventurePointsOption),
+        }),
         cantrips: DB.Optional({
             type: DB.IncludeIdentifier(CantripsOptions),
         }),
@@ -447,6 +450,9 @@ const ProfessionPackageOptions = DB.TypeAlias(import.meta.url, {
         skills: DB.Optional({
             type: DB.IncludeIdentifier(SkillsOptions),
         }),
+        spellworks: DB.Optional({
+            type: DB.IncludeIdentifier(SpellworksOptions),
+        }),
         liturgies: DB.Optional({
             type: DB.IncludeIdentifier(LiturgiesOptions),
         }),
@@ -471,6 +477,11 @@ const ProfessionVariantPackageOptions = DB.TypeAlias(import.meta.url, {
                 DB.IncludeIdentifier(CombatTechniquesOptions),
             ]),
         }),
+        combatTechniquesForAdventurePoints: DB.Optional({
+            type: DB.GenIncludeIdentifier(VariantOptionAction, [
+                DB.IncludeIdentifier(CombatTechniquesForAdventurePointsOption),
+            ]),
+        }),
         cantrips: DB.Optional({
             type: DB.GenIncludeIdentifier(VariantOptionAction, [
                 DB.IncludeIdentifier(CantripsOptions),
@@ -482,6 +493,11 @@ const ProfessionVariantPackageOptions = DB.TypeAlias(import.meta.url, {
         skills: DB.Optional({
             type: DB.GenIncludeIdentifier(VariantOptionAction, [DB.IncludeIdentifier(SkillsOptions)]),
         }),
+        spellworks: DB.Optional({
+            type: DB.GenIncludeIdentifier(VariantOptionAction, [
+                DB.IncludeIdentifier(SpellworksOptions),
+            ]),
+        }),
         liturgies: DB.Optional({
             type: DB.GenIncludeIdentifier(VariantOptionAction, [
                 DB.IncludeIdentifier(LiturgiesOptions),
@@ -558,6 +574,20 @@ const RatingForCombatTechniquesNumber = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
+const CombatTechniquesForAdventurePointsOption = DB.TypeAlias(import.meta.url, {
+    name: "CombatTechniquesForAdventurePointsOption",
+    comment: `Distribe a set amount of Adventure Points among a given set of combat techniques.`,
+    type: () => DB.Object({
+        apValue: DB.Required({
+            comment: `The AP value to distribute.`,
+            type: DB.Integer({ minimum: 2 }),
+        }),
+        options: DB.Required({
+            comment: "The list of combat techniques to distribute to.",
+            type: DB.Array(DB.IncludeIdentifier(CombatTechniqueIdentifier), { minItems: 2 }),
+        }),
+    }),
+});
 const CantripsOptions = DB.TypeAlias(import.meta.url, {
     name: "CantripsOptions",
     comment: `Select one or more cantrips you receive.`,
@@ -605,6 +635,20 @@ const SkillsOptions = DB.TypeAlias(import.meta.url, {
             : undefined,
     ].filter(isNotNullish),
 });
+const SpellworksOptions = DB.TypeAlias(import.meta.url, {
+    name: "SpellworksOptions",
+    comment: `Buy a set number of spells and rituals for a specific amount of AP.`,
+    type: () => DB.Object({
+        number: DB.Required({
+            comment: "The number of spells and rituals to select.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        apValue: DB.Required({
+            comment: "The AP value you can buy spells and rituals for.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
 const LiturgiesOptions = DB.TypeAlias(import.meta.url, {
     name: "LiturgiesOptions",
     comment: `Buy liturgical chants and ceremonies for a specific amount of AP.`,

package/lib/types/Race.d.ts

@@ -23,7 +23,7 @@ export declare const Race: DB.Entity<"Race", {
             number: DB.MemberDecl<DB.Integer, true>;
             sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
         }>, []>>, true>;
-    }>, true>;
+    }>, false>;
     variants: DB.MemberDecl<DB.ChildEntities<DB.Entity<"RaceVariant", {
         race: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         attribute_adjustments: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttributeAdjustments", DB.Object<{

package/lib/types/Race.js

@@ -29,7 +29,7 @@ export const Race = DB.Entity(import.meta.url, {
             comment: "Configuration for random weight generation.",
             type: DB.IncludeIdentifier(RandomWeightGeneration),
         }),
-        starting_age: DB.Required({
+        starting_age: DB.Optional({
             comment: "Defines the starting ages for the race. It depends on the selected experience level.",
             type: DB.NestedEntityMap({
                 name: "StartingAgeConfigForExperienceLevel",

package/lib/types/_ActivatableMagical.d.ts

@@ -4,4 +4,6 @@ export declare const subtype: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Ad
     MagicalTitle: DB.EnumCase<null>;
     MagicalHonor: DB.EnumCase<null>;
     MagicalPunishment: DB.EnumCase<null>;
+    BlessedRank: DB.EnumCase<null>;
+    BlessedTitle: DB.EnumCase<null>;
 }, []>>, false>;

package/lib/types/_ActivatableMagical.js

@@ -6,6 +6,8 @@ const AdvantageDisadvantageSubtype = DB.Enum(import.meta.url, {
         MagicalTitle: DB.EnumCase({ type: null }),
         MagicalHonor: DB.EnumCase({ type: null }),
         MagicalPunishment: DB.EnumCase({ type: null }),
+        BlessedRank: DB.EnumCase({ type: null }),
+        BlessedTitle: DB.EnumCase({ type: null }),
     }),
 });
 export const subtype = DB.Optional({ type: DB.IncludeIdentifier(AdvantageDisadvantageSubtype) });

package/lib/types/_Identifier.d.ts

@@ -36,6 +36,7 @@ export declare const CantripIdentifier: () => R;
 export declare const CauldronEnchantmentIdentifier: () => R;
 export declare const CeremonialItemIdentifier: () => R;
 export declare const CeremonialItemSpecialAbilityIdentifier: () => R;
+export declare const CeremonialItemSpecialAbilityGroupIdentifier: () => R;
 export declare const CeremonyIdentifier: () => R;
 export declare const ChronicleEnchantmentIdentifier: () => R;
 export declare const CloseCombatTechniqueIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -127,6 +127,7 @@ import { Sermon } from "./specialAbility/Sermon.js";
 import { SexSpecialAbility } from "./specialAbility/SexSpecialAbility.js";
 import { SikaryanDrainSpecialAbility } from "./specialAbility/SikaryanDrainSpecialAbility.js";
 import { SkillStyleSpecialAbility } from "./specialAbility/SkillStyleSpecialAbility.js";
+import { CeremonialItemSpecialAbilityGroup } from "./specialAbility/sub/CeremonialItemSpecialAbilityGroup.js";
 import { Language, LanguageSpecialization } from "./specialAbility/sub/Language.js";
 import { Script } from "./specialAbility/sub/Script.js";
 import { TradeSecret } from "./specialAbility/sub/TradeSecret.js";
@@ -200,6 +201,7 @@ export const CantripIdentifier = () => R(Cantrip);
 export const CauldronEnchantmentIdentifier = () => R(CauldronEnchantment);
 export const CeremonialItemIdentifier = () => R(CeremonialItem);
 export const CeremonialItemSpecialAbilityIdentifier = () => R(CeremonialItemSpecialAbility);
+export const CeremonialItemSpecialAbilityGroupIdentifier = () => R(CeremonialItemSpecialAbilityGroup);
 export const CeremonyIdentifier = () => R(Ceremony);
 export const ChronicleEnchantmentIdentifier = () => R(ChronicleEnchantment);
 export const CloseCombatTechniqueIdentifier = () => R(CloseCombatTechnique);

package/lib/types/index.d.ts

@@ -48,9 +48,9 @@ export { RopeOrChain } from "./equipment/item/RopeOrChain.js";
 export { Stationery } from "./equipment/item/Stationery.js";
 export { ArmorType } from "./equipment/item/sub/ArmorType.js";
 export { Biome } from "./equipment/item/sub/Biome.js";
-export { SubBiome } from "./equipment/item/sub/SubBiome.js";
-export { Reach } from "./equipment/item/sub/Reach.js";
 export { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js";
+export { Reach } from "./equipment/item/sub/Reach.js";
+export { SubBiome } from "./equipment/item/sub/SubBiome.js";
 export { ThievesTool } from "./equipment/item/ThievesTool.js";
 export { ToolOfTheTrade } from "./equipment/item/ToolOfTheTrade.js";
 export { TravelGearOrTool } from "./equipment/item/TravelGearOrTool.js";
@@ -130,6 +130,7 @@ export { Sermon } from "./specialAbility/Sermon.js";
 export { SexSpecialAbility } from "./specialAbility/SexSpecialAbility.js";
 export { SikaryanDrainSpecialAbility } from "./specialAbility/SikaryanDrainSpecialAbility.js";
 export { SkillStyleSpecialAbility } from "./specialAbility/SkillStyleSpecialAbility.js";
+export { CeremonialItemSpecialAbilityGroup } from "./specialAbility/sub/CeremonialItemSpecialAbilityGroup.js";
 export { Language } from "./specialAbility/sub/Language.js";
 export { Script } from "./specialAbility/sub/Script.js";
 export { TradeSecret } from "./specialAbility/sub/TradeSecret.js";

package/lib/types/index.js

@@ -48,9 +48,9 @@ export { RopeOrChain } from "./equipment/item/RopeOrChain.js";
 export { Stationery } from "./equipment/item/Stationery.js";
 export { ArmorType } from "./equipment/item/sub/ArmorType.js";
 export { Biome } from "./equipment/item/sub/Biome.js";
-export { SubBiome } from "./equipment/item/sub/SubBiome.js";
-export { Reach } from "./equipment/item/sub/Reach.js";
 export { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js";
+export { Reach } from "./equipment/item/sub/Reach.js";
+export { SubBiome } from "./equipment/item/sub/SubBiome.js";
 export { ThievesTool } from "./equipment/item/ThievesTool.js";
 export { ToolOfTheTrade } from "./equipment/item/ToolOfTheTrade.js";
 export { TravelGearOrTool } from "./equipment/item/TravelGearOrTool.js";
@@ -130,6 +130,7 @@ export { Sermon } from "./specialAbility/Sermon.js";
 export { SexSpecialAbility } from "./specialAbility/SexSpecialAbility.js";
 export { SikaryanDrainSpecialAbility } from "./specialAbility/SikaryanDrainSpecialAbility.js";
 export { SkillStyleSpecialAbility } from "./specialAbility/SkillStyleSpecialAbility.js";
+export { CeremonialItemSpecialAbilityGroup } from "./specialAbility/sub/CeremonialItemSpecialAbilityGroup.js";
 export { Language } from "./specialAbility/sub/Language.js";
 export { Script } from "./specialAbility/sub/Script.js";
 export { TradeSecret } from "./specialAbility/sub/TradeSecret.js";

package/lib/types/specialAbility/CeremonialItemSpecialAbility.d.ts

@@ -1,5 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const CeremonialItemSpecialAbility: DB.Entity<"CeremonialItemSpecialAbility", {
+    associatedItem: DB.MemberDecl<DB.ReferenceIdentifier, false>;
     levels: DB.MemberDecl<DB.Integer, false>;
     nameBuilderRules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableNameBuilderRules", DB.Object<{
         levelPlacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableNameLevelPlacement", {

package/lib/types/specialAbility/CeremonialItemSpecialAbility.js

@@ -1,10 +1,11 @@
 import * as DB from "tsondb/schema/dsl";
 import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
-import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
+import { nameBuilderRules } from "../_ActivatableNames.js";
 import { aspectOptional } from "../_ActivatableNonMundane.js";
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js";
+import { CeremonialItemSpecialAbilityGroupIdentifier } from "../_Identifier.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
 import { NestedTranslationMap } from "../Locale.js";
 import { Errata } from "../source/_Erratum.js";
@@ -13,6 +14,9 @@ export const CeremonialItemSpecialAbility = DB.Entity(import.meta.url, {
     name: "CeremonialItemSpecialAbility",
     namePlural: "CeremonialItemSpecialAbilities",
     type: () => DB.Object({
+        associatedItem: DB.Optional({
+            type: CeremonialItemSpecialAbilityGroupIdentifier(),
+        }),
         levels,
         nameBuilderRules,
         select_options,
@@ -38,7 +42,29 @@ export const CeremonialItemSpecialAbility = DB.Entity(import.meta.url, {
         })),
     }),
     instanceDisplayName: {},
-    instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
+    instanceDisplayNameCustomizer: ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, locales, getDisplayNameForInstanceId, }) => {
+        for (const locale of locales) {
+            const translation = instance.translations[locale];
+            if (translation) {
+                const parent = instance.associatedItem === undefined
+                    ? undefined
+                    : getDisplayNameForInstanceId("CeremonialItemSpecialAbilityGroup", instance.associatedItem);
+                return {
+                    name: (parent === undefined ? "" : parent.name + " — ") +
+                        (translation.name_in_library ?? translation.name),
+                    localeId: locale,
+                };
+            }
+        }
+        //   {
+        //   name:
+        //     instanceDisplayName.length > 0
+        //       ? instanceDisplayName
+        //       : (getDisplayNameForInstanceId(instance.parent)?.name ?? ""),
+        //   localeId: instanceDisplayNameLocaleId,
+        // }
+        return { name: instanceDisplayName, localeId: instanceDisplayNameLocaleId };
+    },
     uniqueConstraints: [
         [
             {

package/lib/types/specialAbility/sub/CeremonialItemSpecialAbilityGroup.d.ts

@@ -0,0 +1,7 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const CeremonialItemSpecialAbilityGroup: DB.Entity<"CeremonialItemSpecialAbilityGroup", {
+    translations: DB.MemberDecl<DB.NestedEntityMap<"CeremonialItemSpecialAbilityGroupTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        nameForSorting: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/specialAbility/sub/CeremonialItemSpecialAbilityGroup.js

@@ -0,0 +1,31 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "../../Locale.js";
+export const CeremonialItemSpecialAbilityGroup = DB.Entity(import.meta.url, {
+    name: "CeremonialItemSpecialAbilityGroup",
+    namePlural: "CeremonialItemSpecialAbilityGroups",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "CeremonialItemSpecialAbilityGroup", DB.Object({
+            name: DB.Required({
+                comment: "The name of the ceremonial item. This should be the heading used in the respective publication.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            nameForSorting: DB.Required({
+                comment: "The name of the ceremonial item for sorting purposes, if different from the actual name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {
+        pathInLocaleMap: "nameForSorting",
+    },
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "nameForSorting",
+        },
+    ],
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.63.1",
+  "version": "0.64.0",
   "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",