optolith-database-schema 0.40.0 → 0.42.0

package/lib/types/Ceremony.d.ts

@@ -194,6 +194,7 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
                         base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                             QualityLevels: DB.EnumCase<null>;
                             SkillPoints: DB.EnumCase<null>;
+                            SkillRating: DB.EnumCase<null>;
                         }, []>>, true>;
                         modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                             arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
@@ -279,6 +280,7 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
                     base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                         QualityLevels: DB.EnumCase<null>;
                         SkillPoints: DB.EnumCase<null>;
+                        SkillRating: DB.EnumCase<null>;
                     }, []>>, true>;
                     modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                         arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
@@ -420,6 +422,7 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
                         base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                             QualityLevels: DB.EnumCase<null>;
                             SkillPoints: DB.EnumCase<null>;
+                            SkillRating: DB.EnumCase<null>;
                         }, []>>, true>;
                         modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                             arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {

package/lib/types/DerivedCharacteristic.d.ts

@@ -1,7 +1,27 @@
 import * as DB from "tsondb/schema/dsl";
+import type { DerivedCharacteristicBase } from "../../gen/types.js";
 import { MathOperation } from "./_MathExpression.ts";
 export declare const DerivedCharacteristic: DB.Entity<"DerivedCharacteristic", {
     position: DB.MemberDecl<DB.Integer, true>;
+    type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicType", {
+        Energy: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"EnergyType", DB.Object<{
+            purchase: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPurchase", DB.Object<{
+                improvementCost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
+                    A: DB.EnumCase<null>;
+                    B: DB.EnumCase<null>;
+                    C: DB.EnumCase<null>;
+                    D: DB.EnumCase<null>;
+                }, []>>, true>;
+                maximum: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
+            }>, []>>, false>;
+            permanentLoss: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPermanentLoss", DB.Object<{
+                canBeBoughtBack: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBuyBack", DB.Object<{
+                    cost: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>, false>;
+            }>, []>>, false>;
+        }>, []>>>;
+        Resistance: DB.EnumCase<null>;
+    }, []>>, false>;
     calculation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicCalculation", DB.Object<{
         base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
         modifiers: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicModifier", DB.Object<{
@@ -165,20 +185,6 @@ export declare const DerivedCharacteristic: DB.Entity<"DerivedCharacteristic", {
             }, []>>, true>;
             value: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, false>;
-        purchasable: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPurchase", DB.Object<{
-            improvementCost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
-                A: DB.EnumCase<null>;
-                B: DB.EnumCase<null>;
-                C: DB.EnumCase<null>;
-                D: DB.EnumCase<null>;
-            }, []>>, true>;
-            maximum: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
-        }>, []>>, false>;
-        permanentLoss: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPermanentLoss", DB.Object<{
-            canBeBoughtBack: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBuyBack", DB.Object<{
-                cost: DB.MemberDecl<DB.Integer, true>;
-            }>, []>>, false>;
-        }>, []>>, false>;
     }>, []>>, true>;
     prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
         Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
@@ -256,3 +262,6 @@ export declare const DerivedCharacteristic: DB.Entity<"DerivedCharacteristic", {
         }>, []>>, false>;
     }>, true>;
 }, undefined>;
+declare const DerivedCharacteristicBase: DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>;
+export declare const calculationContainsRaceBase: (base: DerivedCharacteristicBase) => boolean;
+export {};

package/lib/types/DerivedCharacteristic.js

@@ -1,4 +1,6 @@
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import * as DB from "tsondb/schema/dsl";
+import { fromUniformCase } from "tsondb/schema/gen";
 import { NestedTranslationMap } from "./Locale.js";
 import { AttributeIdentifier } from "./_Identifier.js";
 import { ImprovementCost } from "./_ImprovementCost.js";
@@ -14,6 +16,10 @@ export const DerivedCharacteristic = DB.Entity(import.meta.url, {
             comment: "The position of the derived characteristic in lists. This has to be a unique value.",
             type: DB.Integer({ minimum: 0 }),
         }),
+        type: DB.Optional({
+            comment: "The derived characteristic may have a specific use in the game.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicType),
+        }),
         calculation: DB.Required({
             comment: "Instructions for calculating the derived characteristic’s value.",
             type: DB.IncludeIdentifier(DerivedCharacteristicCalculation),
@@ -59,6 +65,34 @@ export const DerivedCharacteristic = DB.Entity(import.meta.url, {
         },
     ],
 });
+const DerivedCharacteristicType = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicType",
+    comment: "The type of the derived characteristic, which determines how it can be used in the game.",
+    values: () => ({
+        Energy: DB.EnumCase({
+            comment: "The derived characteristic works like an energy in that it can be spent on various actions and abilities, and also be refilled based on certain conditions.",
+            type: DB.IncludeIdentifier(EnergyType),
+        }),
+        Resistance: DB.EnumCase({
+            comment: "The derived characteristic represents a resistance against certain effects.",
+            type: null,
+        }),
+    }),
+});
+const EnergyType = DB.TypeAlias(import.meta.url, {
+    name: "EnergyType",
+    comment: "Additional values that can be defined for an energy.",
+    type: () => DB.Object({
+        purchase: DB.Optional({
+            comment: "If set, the energy’s maximum value can be improved by spending AP.\n\nIf the energy’s permanent losses can be bought back, points will not be able to be purchased unless all permanent losses have been bought back.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicPurchase),
+        }),
+        permanentLoss: DB.Optional({
+            comment: "If set, the energy can suffer permanent losses that reduce its maximum value. It may also be possible to buy back these permanent losses.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicPermanentLoss),
+        }),
+    }),
+});
 const DerivedCharacteristicCalculation = DB.TypeAlias(import.meta.url, {
     name: "DerivedCharacteristicCalculation",
     type: () => DB.Object({
@@ -70,23 +104,6 @@ const DerivedCharacteristicCalculation = DB.TypeAlias(import.meta.url, {
             comment: "A list of modifiers that are applied to the base value. The modifiers are applied in the order they appear in the list.",
             type: DB.Array(DB.IncludeIdentifier(DerivedCharacteristicModifier), { minItems: 1 }),
         }),
-        purchasable: DB.Optional({
-            comment: "If set, the derived characteristic can be improved by spending AP.\n\nIf the derived characteristic’s permanent losses can be bought back, points will not be able to be purchased unless all permanent losses have been bought back.",
-            type: DB.IncludeIdentifier(DerivedCharacteristicPurchase),
-        }),
-        permanentLoss: DB.Optional({
-            comment: "If set, the derived characteristic can suffer permanent losses that reduce its maximum value. It may also be possible to buy back these permanent losses.",
-            type: DB.IncludeIdentifier(DerivedCharacteristicPermanentLoss),
-        }),
-    }),
-});
-const DerivedCharacteristicRaceBaseValue = DB.Enum(import.meta.url, {
-    name: "DerivedCharacteristicRaceBaseValue",
-    values: () => ({
-        LifePoints: DB.EnumCase({ type: null }),
-        Spirit: DB.EnumCase({ type: null }),
-        Toughness: DB.EnumCase({ type: null }),
-        Movement: DB.EnumCase({ type: null }),
     }),
 });
 const DerivedCharacteristicPrimaryAttributeValue = DB.Enum(import.meta.url, {
@@ -101,10 +118,7 @@ const DerivedCharacteristicBaseValue = DB.Enum(import.meta.url, {
     values: () => ({
         Constant: DB.EnumCase({ type: DB.Integer() }),
         Attribute: DB.EnumCase({ type: AttributeIdentifier() }),
-        RaceBaseValue: DB.EnumCase({
-            displayName: "Base Value from Race",
-            type: DB.IncludeIdentifier(DerivedCharacteristicRaceBaseValue),
-        }),
+        RaceBaseValue: DB.EnumCase({ displayName: "Base Value from Race", type: null }),
         PrimaryAttribute: DB.EnumCase({
             type: DB.IncludeIdentifier(DerivedCharacteristicPrimaryAttributeValue),
         }),
@@ -114,6 +128,29 @@ const DerivedCharacteristicBase = DB.TypeAlias(import.meta.url, {
     name: "DerivedCharacteristicBase",
     type: () => DB.GenIncludeIdentifier(MathOperation, [DB.IncludeIdentifier(DerivedCharacteristicBaseValue)]),
 });
+export const calculationContainsRaceBase = (base) => {
+    switch (base.kind) {
+        case "Value":
+            switch (base.Value.kind) {
+                case "RaceBaseValue":
+                    return true;
+                case "Constant":
+                case "Attribute":
+                case "PrimaryAttribute":
+                    return false;
+                default:
+                    return assertExhaustive(base.Value);
+            }
+        case "Addition":
+        case "Subtraction":
+        case "Multiplication":
+        case "Division":
+        case "Exponentiation": {
+            const [left, right] = fromUniformCase(base);
+            return calculationContainsRaceBase(left) || calculationContainsRaceBase(right);
+        }
+    }
+};
 const DerivedCharacteristicModifierOperation = DB.Enum(import.meta.url, {
     name: "DerivedCharacteristicModifierOperation",
     values: () => ({

package/lib/types/Disease.d.ts

@@ -41,6 +41,8 @@ export declare const Disease: DB.Entity<"Disease", {
             }>, [T: DB.Param<"T", DB.Type>]>>>;
         }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
     }>, []>>, false>;
+    isChildhoodDisease: DB.MemberDecl<DB.Boolean, true>;
+    isMagicalDisease: DB.MemberDecl<DB.Boolean, true>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {

package/lib/types/Disease.js

@@ -14,6 +14,14 @@ export const Disease = DB.Entity(import.meta.url, {
             comment: "AP value and prerequisites of the disease’s trade secret.",
             type: DB.IncludeIdentifier(RecipeTradeSecret),
         }),
+        isChildhoodDisease: DB.Required({
+            comment: "Whether the disease is a childhood disease.",
+            type: DB.Boolean(),
+        }),
+        isMagicalDisease: DB.Required({
+            comment: "Whether the disease is a magical disease.",
+            type: DB.Boolean(),
+        }),
         src,
         translations: NestedTranslationMap(DB.Required, "Disease", DiseaseTranslation),
     }),

package/lib/types/FamiliarsTrick.d.ts

@@ -1,6 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const FamiliarsTrick: DB.Entity<"FamiliarsTrick", {
     animal_types: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    traditions: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
     parameters: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"FamiliarsTrickPerformanceParameters", {
         OneTime: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FamiliarsTrickOneTimePerformanceParameters", DB.Object<{
             cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"FamiliarsTrickOneTimeCost", {

package/lib/types/FamiliarsTrick.js

@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl";
 import { OldParameter } from "./_ActivatableSkill.js";
 import { IndefiniteOneTimeCost, NonModifiableOneTimeCostPerCountable, } from "./_ActivatableSkillCost.js";
 import { DurationUnitValue, FixedDuration, IndefiniteDuration, } from "./_ActivatableSkillDuration.js";
-import { AnimalTypeIdentifier, PropertyIdentifier } from "./_Identifier.js";
+import { AnimalTypeIdentifier, MagicalTraditionIdentifier, PropertyIdentifier, } from "./_Identifier.js";
 import { ResponsiveText } from "./_ResponsiveText.js";
 import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
@@ -16,9 +16,15 @@ export const FamiliarsTrick = DB.Entity(import.meta.url, {
         animal_types: DB.Required({
             comment: `The animal types this trick is available to. Either it is available to all or only a list of specific animal types.
 
-If no animal types are given, the animal disease applies to all animal types.`,
+If no animal types are given, the familiars trick applies to all animal types.`,
             type: DB.Array(AnimalTypeIdentifier(), { uniqueItems: true }),
         }),
+        traditions: DB.Optional({
+            comment: `The magical traditions whose familiars can use this trick. Either it is available to all or only a list of specific traditions.
+
+If no traditions are given, the familiars trick is not restricted by the magical tradition at all.`,
+            type: DB.Array(MagicalTraditionIdentifier(), { uniqueItems: true, minItems: 1 }),
+        }),
         parameters: DB.Required({
             comment: "Measurable parameters of a familiar’s trick.",
             type: DB.IncludeIdentifier(FamiliarsTrickPerformanceParameters),

package/lib/types/LiturgicalChant.d.ts

@@ -194,6 +194,7 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
                         base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                             QualityLevels: DB.EnumCase<null>;
                             SkillPoints: DB.EnumCase<null>;
+                            SkillRating: DB.EnumCase<null>;
                         }, []>>, true>;
                         modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                             arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
@@ -279,6 +280,7 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
                     base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                         QualityLevels: DB.EnumCase<null>;
                         SkillPoints: DB.EnumCase<null>;
+                        SkillRating: DB.EnumCase<null>;
                     }, []>>, true>;
                     modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                         arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
@@ -420,6 +422,7 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
                         base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                             QualityLevels: DB.EnumCase<null>;
                             SkillPoints: DB.EnumCase<null>;
+                            SkillRating: DB.EnumCase<null>;
                         }, []>>, true>;
                         modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                             arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {

package/lib/types/Locale.d.ts

@@ -75,7 +75,7 @@ export declare const Locale: DB.Entity<"Locale", {
         "Personal Data": null;
         "Character Sheet": null;
         Pact: null;
-        Rules: null;
+        "Rule Set": null;
         "Race, Culture & Profession": null;
         Race: null;
         Culture: null;
@@ -902,6 +902,7 @@ export declare const Locale: DB.Entity<"Locale", {
         CD: null;
         Object: null;
         Effect: null;
+        Rules: null;
         "Casting Time": null;
         "Ritual Time": null;
         "Liturgical Time": null;
@@ -1514,6 +1515,8 @@ export declare const Locale: DB.Entity<"Locale", {
         ".input {$value :number} {{{$value}%}}": null;
         "Animal Types": null;
         "Communicability to Intelligent Creatures": null;
+        "childhood disease": null;
+        "magical disease": null;
         "Can be combined with": null;
         Skill: null;
         "{$defaultDuration}, but no more than {$maximumDuration}": null;
@@ -1533,10 +1536,7 @@ export declare const Locale: DB.Entity<"Locale", {
         "All AE": null;
         "All AE, at least {$value} AE": null;
         "depends on spent AE": null;
-        "Life Point Base Value": null;
-        "Spirit Base Value": null;
-        "Toughness Base Value": null;
-        "Movement Base Value": null;
+        "{$derivedCharacteristic} Base Value": null;
         "Attribute Adjustments": null;
         "one attribute of your choice": null;
         "Common Cultures": null;
@@ -1576,12 +1576,13 @@ export declare const Locale: DB.Entity<"Locale", {
         "no Skill Specialization for a {$skillOfGroup}": null;
         ".input {$count :number} {{{$count} of the following combat techniques {$rating}}}": null;
         ".input {$count :number} {{{$previous}, {$count} others {$rating}}}": null;
-        "{$previous}, all others {$rating}": null;
+        "{$previous}, the others {$rating}": null;
         "Curses totaling {$apValue} AP": null;
         "no Curses totaling {$apValue} AP": null;
         "Liturgies totaling {$apValue} AP": null;
         "no Liturgies totaling {$apValue} AP": null;
         "{$apValue} AP to improve other {$skillsOfGroup}": null;
+        "{$apValue} AP to distribute among the following skills: {$list}": null;
         "no AP to improve other {$skillsOfGroup}": null;
         ".input {$count :number} {{{$count} cantrips}}": null;
         "{$count} from the following list": null;
@@ -1592,6 +1593,9 @@ export declare const Locale: DB.Entity<"Locale", {
         Enhancements: null;
         "SR {$value}": null;
         ".input {$hiddenCount :number} {{Prerequisites}}": null;
+        "Spell Enhancement {$spell}": null;
+        "Ritual Enhancement {$ritual}": null;
+        "Liturgical Enhancement {$liturgicalChantOrCeremony}": null;
         "Profession Package": null;
         "Optional Rule": null;
     }>, false>;

package/lib/types/Locale.js

@@ -94,7 +94,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Personal Data": null,
                 "Character Sheet": null,
                 "Pact": null,
-                "Rules": null,
+                "Rule Set": null,
                 "Race, Culture & Profession": null,
                 "Race": null,
                 "Culture": null,
@@ -926,6 +926,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 "CD": null,
                 "Object": null,
                 "Effect": null,
+                "Rules": null,
                 "Casting Time": null,
                 "Ritual Time": null,
                 "Liturgical Time": null,
@@ -1558,6 +1559,8 @@ export const Locale = DB.Entity(import.meta.url, {
                 ".input {$value :number} {{{$value}%}}": null,
                 "Animal Types": null,
                 "Communicability to Intelligent Creatures": null,
+                "childhood disease": null,
+                "magical disease": null,
                 // personality traits
                 "Can be combined with": null,
                 // magical actions
@@ -1581,10 +1584,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 "All AE, at least {$value} AE": null,
                 "depends on spent AE": null,
                 // races
-                "Life Point Base Value": null,
-                "Spirit Base Value": null,
-                "Toughness Base Value": null,
-                "Movement Base Value": null,
+                "{$derivedCharacteristic} Base Value": null,
                 "Attribute Adjustments": null,
                 "one attribute of your choice": null,
                 "Common Cultures": null,
@@ -1626,12 +1626,13 @@ export const Locale = DB.Entity(import.meta.url, {
                 "no Skill Specialization for a {$skillOfGroup}": null,
                 ".input {$count :number} {{{$count} of the following combat techniques {$rating}}}": null,
                 ".input {$count :number} {{{$previous}, {$count} others {$rating}}}": null,
-                "{$previous}, all others {$rating}": null,
+                "{$previous}, the others {$rating}": null,
                 "Curses totaling {$apValue} AP": null,
                 "no Curses totaling {$apValue} AP": null,
                 "Liturgies totaling {$apValue} AP": null,
                 "no Liturgies totaling {$apValue} AP": null,
                 "{$apValue} AP to improve other {$skillsOfGroup}": null,
+                "{$apValue} AP to distribute among the following skills: {$list}": null,
                 "no AP to improve other {$skillsOfGroup}": null,
                 ".input {$count :number} {{{$count} cantrips}}": null,
                 "{$count} from the following list": null,
@@ -1643,6 +1644,9 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Enhancements": null,
                 "SR {$value}": null,
                 ".input {$hiddenCount :number} {{Prerequisites}}": null,
+                "Spell Enhancement {$spell}": null,
+                "Ritual Enhancement {$ritual}": null,
+                "Liturgical Enhancement {$liturgicalChantOrCeremony}": null,
                 // Library Entry Subtitles
                 "Profession Package": null,
                 "Optional Rule": null,

package/lib/types/Profession.d.ts

@@ -71,6 +71,7 @@ export declare const Profession: DB.Entity<"Profession", {
                 }>, []>>, false>;
                 skills: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillsOptions", DB.Object<{
                     group: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    specific: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                     ap_value: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>, false>;
                 liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
@@ -79,7 +80,8 @@ export declare const Profession: DB.Entity<"Profession", {
             }>, []>>, false>;
             special_abilities: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
                 Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                        Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -156,7 +158,8 @@ export declare const Profession: DB.Entity<"Profession", {
                 }>, []>>>;
                 Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                     options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                            Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -342,7 +345,8 @@ export declare const Profession: DB.Entity<"Profession", {
                     }, []>>, true>;
                     value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
                         Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                                Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -419,7 +423,8 @@ export declare const Profession: DB.Entity<"Profession", {
                         }>, []>>>;
                         Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                             options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                                    Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -704,6 +709,7 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
             }>, []>>, false>;
             skills: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillsOptions", DB.Object<{
                 group: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                specific: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                 ap_value: DB.MemberDecl<DB.Integer, true>;
             }>, []>>, false>;
             liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
@@ -712,7 +718,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
         }>, []>>, false>;
         special_abilities: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
             Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                    Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -789,7 +796,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
             }>, []>>>;
             Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                 options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                        Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -975,7 +983,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                 }, []>>, true>;
                 value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
                     Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                            Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1052,7 +1061,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                     }>, []>>>;
                     Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                         options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                                Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1329,6 +1339,7 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
         }>, []>>, false>;
         skills: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillsOptions", DB.Object<{
             group: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            specific: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             ap_value: DB.MemberDecl<DB.Integer, true>;
         }>, []>>, false>;
         liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
@@ -1337,7 +1348,8 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
     }>, []>>, false>;
     special_abilities: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
         Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1414,7 +1426,8 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
         }>, []>>>;
         Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
             options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                    Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1600,7 +1613,8 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
             }, []>>, true>;
             value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
                 Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                        Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1677,7 +1691,8 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
                 }>, []>>>;
                 Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                     options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                            Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1874,7 +1889,8 @@ export declare const ProfessionVariant: DB.Entity<"ProfessionVariant", {
         }, []>>, true>;
         value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
             Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                    Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1951,7 +1967,8 @@ export declare const ProfessionVariant: DB.Entity<"ProfessionVariant", {
             }>, []>>>;
             Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                 options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                        Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;

package/lib/types/Profession.js

@@ -1,7 +1,8 @@
+import { isNotNullish } from "@elyukai/utils/nullable";
 import * as DB from "tsondb/schema/dsl";
 import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantageDisadvantage.js";
 import { AdvantageIdentifier, CantripIdentifier, CurriculumIdentifier, DisadvantageIdentifier, ExperienceLevelIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, ProfessionPackageIdentifier, ProfessionVersionIdentifier, SkillGroupIdentifier, SkillIdentifier, } from "./_Identifier.js";
-import { CombatTechniqueIdentifier, LiturgyIdentifier, MagicalActionIdentifier, RequirableSelectOptionIdentifier, SpecialAbilityIdentifier, SpellworkIdentifier, } from "./_IdentifierGroup.js";
+import { CombatTechniqueIdentifier, LiturgyIdentifier, MagicalActionIdentifier, ProfessionSpecialAbilityIdentifier, RequirableSelectOptionIdentifier, SpellworkIdentifier, } from "./_IdentifierGroup.js";
 import { ProfessionPrerequisites } from "./_Prerequisite.js";
 import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
@@ -305,7 +306,7 @@ const ConstantProfessionSpecialAbility = DB.TypeAlias(import.meta.url, {
     type: () => DB.Object({
         id: DB.Required({
             comment: "The identifier of the special ability to grant.",
-            type: DB.IncludeIdentifier(SpecialAbilityIdentifier),
+            type: DB.IncludeIdentifier(ProfessionSpecialAbilityIdentifier),
         }),
         level: DB.Optional({
             comment: "The level of the received special ability. If not specified and the special ability has levels, level 1 is used automatically.",
@@ -585,11 +586,20 @@ const SkillsOptions = DB.TypeAlias(import.meta.url, {
             comment: "If specified, you may only choose from skills of the specified group.",
             type: SkillGroupIdentifier(),
         }),
+        specific: DB.Optional({
+            comment: "The list of specific skills to distribute AP to.",
+            type: DB.Array(SkillIdentifier(), { minItems: 2 }),
+        }),
         ap_value: DB.Required({
             comment: "The AP value you can buy skills for.",
             type: DB.Integer({ minimum: 1 }),
         }),
     }),
+    customConstraints: ({ instanceContent, getInstanceById }) => [
+        (instanceContent.specific?.some(skillId => getInstanceById("Skill", skillId)?.group !== instanceContent.group) ?? false)
+            ? "All selected skills must be from the selected group."
+            : undefined,
+    ].filter(isNotNullish),
 });
 const LiturgiesOptions = DB.TypeAlias(import.meta.url, {
     name: "LiturgiesOptions",