@optolith/database-schema 0.63.1 → 0.65.0

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,10 @@ 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;
+        "{$apValue} AP to distribute among the following combat techniques: {$list}": null;
+        "no AP to distribute among the following combat techniques: {$list}": null;
+        ".input {$count :number} {{{$count} more spellworks totaling {$apValue} AP}}": null;
+        "{$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,10 @@ 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,
+                "{$apValue} AP to distribute among the following combat techniques: {$list}": null,
+                "no AP to distribute among the following combat techniques: {$list}": null,
+                ".input {$count :number} {{{$count} more spellworks totaling {$apValue} AP}}": null,
+                "{$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.65.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",
@@ -39,7 +39,7 @@
   "license": "MPL-2.0",
   "dependencies": {
     "@elyukai/utils": "^0.3.6",
-    "tsondb": "^0.20.4",
+    "tsondb": "^0.21.1",
     "yaml": "^2.9.0"
   },
   "devDependencies": {