optolith-database-schema 0.28.2 → 0.29.0

package/lib/cache/ancestorBloodAdvantages.d.ts

@@ -0,0 +1,4 @@
+import type { Advantage_ID } from "../../gen/types.js";
+import type { CacheBuilder } from "./internal.ts";
+export type AncestorBloodAdvantagesCache = Advantage_ID[];
+export declare const buildAncestorBloodAdvantagesCache: CacheBuilder<AncestorBloodAdvantagesCache>;

package/lib/cache/ancestorBloodAdvantages.js

@@ -0,0 +1,13 @@
+export const buildAncestorBloodAdvantagesCache = database => database
+    .getAllInstanceContainersOfEntity("Advantage")
+    .filter(({ content }) => content.prerequisites?.some(p => {
+    switch (p.prerequisite.kind) {
+        case "Single":
+            return p.prerequisite.Single.kind === "NoOtherAncestorBloodAdvantage";
+        case "Disjunction":
+            return p.prerequisite.Disjunction.list.some(d => d.kind === "NoOtherAncestorBloodAdvantage");
+        case "Group":
+            return p.prerequisite.Group.list.some(g => g.kind === "NoOtherAncestorBloodAdvantage");
+    }
+}))
+    .map(({ id }) => id);

package/lib/cache/index.d.ts

@@ -0,0 +1,31 @@
+import type { TSONDB } from "tsondb";
+import type { TSONDBTypes } from "../main.ts";
+import { type ActivatableSelectOptionsCache, type ResolvedSelectOption, type ResolvedSelectOptionIdentifier } from "./activatableSelectOptions.ts";
+import { type AncestorBloodAdvantagesCache } from "./ancestorBloodAdvantages.ts";
+import { type MagicalAndBlessedAdvantagesAndDisadvantagesCache } from "./magicalAndBlessedAdvantagesAndDisadvantages.ts";
+import { type NewApplicationsAndUsesCache, type ResolvedNewSkillApplication, type ResolvedSkillUse } from "./newApplicationsAndUses.ts";
+/**
+ * Identifiers of specific entries in the database that are used for creating the cache.
+ */
+export type IdMap = {
+    Advantage: Record<"Blessed" | "Spellcaster", string>;
+    MagicalSpecialAbility: Record<"PropertyKnowledge", string>;
+    KarmaSpecialAbility: Record<"AspectKnowledge", string>;
+};
+/**
+ * The cache object containing all precomputed data.
+ */
+export type Cache = {
+    activatableSelectOptions: ActivatableSelectOptionsCache;
+    sncestorBloodAdvantages: AncestorBloodAdvantagesCache;
+    magicalAndBlessedAdvantagesAndDisadvantages: MagicalAndBlessedAdvantagesAndDisadvantagesCache;
+    newApplicationsAndUses: NewApplicationsAndUsesCache;
+};
+export type { ActivatableSelectOptionsCache, AncestorBloodAdvantagesCache, MagicalAndBlessedAdvantagesAndDisadvantagesCache, NewApplicationsAndUsesCache, ResolvedNewSkillApplication, ResolvedSelectOption, ResolvedSelectOptionIdentifier, ResolvedSkillUse, };
+/**
+ * Creates the cache by precomputing all necessary data from the database.
+ * @param db The TSONDB instance containing the database.
+ * @param idMap An object containing identifiers of specific entries in the database that are used for creating the cache.
+ * @returns The created cache object.
+ */
+export declare const createCache: (db: TSONDB<TSONDBTypes>, idMap: IdMap) => Cache;

package/lib/cache/index.js

@@ -0,0 +1,22 @@
+import { activatableSelectOptionsCacheBuilder, } from "./activatableSelectOptions.js";
+import { buildAncestorBloodAdvantagesCache, } from "./ancestorBloodAdvantages.js";
+import { buildMagicalAndBlessedAdvantagesAndDisadvantagesCache, } from "./magicalAndBlessedAdvantagesAndDisadvantages.js";
+import { buildNewApplicationsAndUsesCache, } from "./newApplicationsAndUses.js";
+/**
+ * Creates the cache by precomputing all necessary data from the database.
+ * @param db The TSONDB instance containing the database.
+ * @param idMap An object containing identifiers of specific entries in the database that are used for creating the cache.
+ * @returns The created cache object.
+ */
+export const createCache = (db, idMap) => {
+    const activatableSelectOptions = activatableSelectOptionsCacheBuilder(db, idMap);
+    const sncestorBloodAdvantages = buildAncestorBloodAdvantagesCache(db, idMap);
+    const magicalAndBlessedAdvantagesAndDisadvantages = buildMagicalAndBlessedAdvantagesAndDisadvantagesCache(db, idMap);
+    const newApplicationsAndUses = buildNewApplicationsAndUsesCache(db, idMap, activatableSelectOptions);
+    return {
+        activatableSelectOptions,
+        sncestorBloodAdvantages,
+        magicalAndBlessedAdvantagesAndDisadvantages,
+        newApplicationsAndUses,
+    };
+};

package/lib/cache/internal.d.ts

@@ -0,0 +1,4 @@
+import type { TSONDB } from "tsondb";
+import type { TSONDBTypes } from "../main.ts";
+import type { IdMap } from "./index.ts";
+export type CacheBuilder<T = unknown, Args extends unknown[] = []> = (db: TSONDB<TSONDBTypes>, idMap: IdMap, ...args: Args) => T;

package/lib/cache/internal.js

@@ -0,0 +1 @@
+export {};

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.d.ts

@@ -0,0 +1,3 @@
+import type { CacheBuilder } from "./internal.ts";
+export type MagicalAndBlessedAdvantagesAndDisadvantagesCache = Record<"Advantage" | "Disadvantage", Record<"Magical" | "Blessed", string[]>>;
+export declare const buildMagicalAndBlessedAdvantagesAndDisadvantagesCache: CacheBuilder<MagicalAndBlessedAdvantagesAndDisadvantagesCache>;

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.js

@@ -0,0 +1,103 @@
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+const getAdvantageId = (idMap, type) => {
+    switch (type) {
+        case "Magical":
+            return idMap.Advantage.Spellcaster;
+        case "Blessed":
+            return idMap.Advantage.Blessed;
+        default:
+            return assertExhaustive(type);
+    }
+};
+const isRatedFor = (type, ratedId) => {
+    switch (ratedId.kind) {
+        case "Spell":
+        case "Ritual":
+            return type === "Magical";
+        case "LiturgicalChant":
+        case "Ceremony":
+            return type === "Blessed";
+        case "Attribute":
+        case "Skill":
+        case "CloseCombatTechnique":
+        case "RangedCombatTechnique":
+            return false;
+        default:
+            return assertExhaustive(ratedId);
+    }
+};
+const isPrerequisiteFor = (idMap, type, prerequisite, getById, traversedIds) => {
+    switch (prerequisite.kind) {
+        case "Activatable": {
+            if (prerequisite.Activatable.id.kind === "Advantage" &&
+                prerequisite.Activatable.id.Advantage === getAdvantageId(idMap, type) &&
+                prerequisite.Activatable.active) {
+                return true;
+            }
+            const entry = getById(prerequisite.Activatable.id);
+            return entry !== undefined && is(idMap, type, entry, getById, traversedIds);
+        }
+        case "Rated":
+            return isRatedFor(type, prerequisite.Rated.id);
+        case "CommonSuggestedByRCP":
+        case "Sex":
+        case "Race":
+        case "Culture":
+        case "Pact":
+        case "SocialStatus":
+        case "State":
+        case "Rule":
+        case "PrimaryAttribute":
+        case "BlessedTradition":
+        case "MagicalTradition":
+        case "RatedMinimumNumber":
+        case "RatedSum":
+        case "Enhancement":
+        case "Text":
+        case "NoOtherAncestorBloodAdvantage":
+        case "SexualCharacteristic":
+            return false;
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+const is = (idMap, type, entry, getById, traversedIds) => {
+    if (!entry.content.prerequisites || traversedIds.includes(entry.id)) {
+        return false;
+    }
+    const newTraversedIds = [...traversedIds, entry.id];
+    return (entry.content.prerequisites !== undefined &&
+        entry.content.prerequisites.some(prerequisite => {
+            switch (prerequisite.prerequisite.kind) {
+                case "Single":
+                    return isPrerequisiteFor(idMap, type, prerequisite.prerequisite.Single, getById, newTraversedIds);
+                case "Disjunction":
+                    return prerequisite.prerequisite.Disjunction.list.some(p => isPrerequisiteFor(idMap, type, p, getById, newTraversedIds));
+                case "Group":
+                    return prerequisite.prerequisite.Group.list.some(p => isPrerequisiteFor(idMap, type, p, getById, newTraversedIds));
+                default:
+                    return assertExhaustive(prerequisite.prerequisite);
+            }
+        }));
+};
+const entityKeyMap = {
+    Advantage: null,
+    Disadvantage: null,
+};
+const typeKeyMap = {
+    Magical: null,
+    Blessed: null,
+};
+const collectIds = (entity, type, database, idMap) => database
+    .getAllInstanceContainersOfEntity(entity)
+    .filter(entry => is(idMap, type, entry, database.getInstanceContainerOfEntityById.bind(database), []))
+    .map(({ id }) => id);
+export const buildMagicalAndBlessedAdvantagesAndDisadvantagesCache = (database, idMap) => {
+    return Object.fromEntries(Object.keys(entityKeyMap).map((entity) => [
+        entity,
+        Object.fromEntries(Object.keys(typeKeyMap).map((type) => [
+            type,
+            collectIds(entity, type, database, idMap),
+        ])),
+    ]));
+};

package/lib/cache/newApplicationsAndUses.d.ts

@@ -0,0 +1,22 @@
+import type { ActivatableIdentifier, NewSkillApplication, NewSkillApplicationOrUseParentIdentifier, Skill_ID, SkillUse } from "../../gen/types.js";
+import type { ActivatableSelectOptionsCache } from "./activatableSelectOptions.ts";
+import type { CacheBuilder } from "./internal.ts";
+export type ResolvedNewSkillApplication = {
+    id: string;
+    content: Omit<NewSkillApplication, "parent"> & {
+        parent: NewSkillApplicationOrUseParentIdentifier | ActivatableIdentifier;
+    };
+};
+export type ResolvedSkillUse = {
+    id: string;
+    content: Omit<SkillUse, "parent"> & {
+        parent: NewSkillApplicationOrUseParentIdentifier | ActivatableIdentifier;
+    };
+};
+export type NewApplicationsAndUsesCache = {
+    newApplications: Record<Skill_ID, ResolvedNewSkillApplication[]>;
+    uses: Record<Skill_ID, ResolvedSkillUse[]>;
+};
+export declare const buildNewApplicationsAndUsesCache: CacheBuilder<NewApplicationsAndUsesCache, [
+    generatedSelectOptions: ActivatableSelectOptionsCache
+]>;

package/lib/cache/newApplicationsAndUses.js

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

package/lib/types/Advantage.d.ts

@@ -852,7 +852,7 @@ export declare const Advantage: DB.Entity<"Advantage", {
                         }, []>>, false>;
                     }>, []>>>, true>;
                     isRemoved: DB.MemberDecl<DB.Boolean, false>;
-                }>, []>>, false>;
+                }>, []>>, true>;
                 revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                     Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                         printing: DB.MemberDecl<DB.Integer, true>;
@@ -1123,7 +1123,7 @@ export declare const Advantage: DB.Entity<"Advantage", {
                 threshold: DB.MemberDecl<DB.Integer, true>;
                 alternative: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("./_MathExpression.js").MathOperation>, []>>>;
+            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("./_MathExpression.ts").MathOperation>, []>>>;
         }, []>>>;
         Indefinite: DB.EnumCase<null>;
     }, []>>, true>;
@@ -1147,7 +1147,7 @@ export declare const Advantage: DB.Entity<"Advantage", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/AnimalDisease.d.ts

@@ -41,7 +41,7 @@ export declare const AnimalDisease: DB.Entity<"AnimalDisease", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Blessing.d.ts

@@ -69,7 +69,7 @@ export declare const Blessing: DB.Entity<"Blessing", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Cantrip.d.ts

@@ -97,7 +97,7 @@ export declare const Cantrip: DB.Entity<"Cantrip", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Ceremony.d.ts

@@ -529,7 +529,7 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;
@@ -643,7 +643,7 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
                         }, []>>, false>;
                     }>, []>>>, true>;
                     isRemoved: DB.MemberDecl<DB.Boolean, false>;
-                }>, []>>, false>;
+                }>, []>>, true>;
                 revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                     Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                         printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/CombatTechnique.d.ts

@@ -53,7 +53,7 @@ export declare const CloseCombatTechnique: DB.Entity<"CloseCombatTechnique", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;
@@ -119,7 +119,7 @@ export declare const RangedCombatTechnique: DB.Entity<"RangedCombatTechnique", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Condition.d.ts

@@ -18,7 +18,7 @@ export declare const Condition: DB.Entity<"Condition", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Culture.d.ts

@@ -86,7 +86,7 @@ export declare const Culture: DB.Entity<"Culture", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/DerivedCharacteristic.d.ts

@@ -43,7 +43,7 @@ export declare const DerivedCharacteristic: DB.Entity<"DerivedCharacteristic", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Disadvantage.d.ts

@@ -852,7 +852,7 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                         }, []>>, false>;
                     }>, []>>>, true>;
                     isRemoved: DB.MemberDecl<DB.Boolean, false>;
-                }>, []>>, false>;
+                }>, []>>, true>;
                 revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                     Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                         printing: DB.MemberDecl<DB.Integer, true>;
@@ -1050,7 +1050,7 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                 threshold: DB.MemberDecl<DB.Integer, true>;
                 alternative: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("./_MathExpression.js").MathOperation>, []>>>;
+            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("./_MathExpression.ts").MathOperation>, []>>>;
         }, []>>>;
         Indefinite: DB.EnumCase<null>;
     }, []>>, true>;
@@ -1074,7 +1074,7 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Disease.d.ts

@@ -59,7 +59,7 @@ export declare const Disease: DB.Entity<"Disease", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/FamiliarsTrick.d.ts

@@ -148,7 +148,7 @@ export declare const FamiliarsTrick: DB.Entity<"FamiliarsTrick", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Lessons.d.ts

@@ -102,7 +102,7 @@ export declare const Curriculum: DB.Entity<"Curriculum", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/LiturgicalChant.d.ts

@@ -529,7 +529,7 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;
@@ -643,7 +643,7 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
                         }, []>>, false>;
                     }>, []>>>, true>;
                     isRemoved: DB.MemberDecl<DB.Boolean, false>;
-                }>, []>>, false>;
+                }>, []>>, true>;
                 revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                     Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                         printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Locale.d.ts

@@ -892,6 +892,7 @@ export declare const Locale: DB.Entity<"Locale", {
         ID: null;
         "Creation Difficulty": null;
         CD: null;
+        Object: null;
         Effect: null;
         "Casting Time": null;
         "Ritual Time": null;
@@ -1022,6 +1023,7 @@ export declare const Locale: DB.Entity<"Locale", {
         " (casting)": null;
         Zone: null;
         "Liturgical Chants and Ceremonies": null;
+        Spellworks: null;
         General: null;
         Note: null;
         all: null;
@@ -1057,6 +1059,9 @@ export declare const Locale: DB.Entity<"Locale", {
         "domain {$domain}": null;
         "{$pact} level {$pactLevel}": null;
         "Level {$level}:": null;
+        ".input {$level :number} {{Level {$level}}}": null;
+        "cannot be chosen at the same time as {$trait}": null;
+        "must have {$trait}": null;
         "inlinewiki.castingtime": null;
         "inlinewiki.ritualtime": null;
         "inlinewiki.aecost": null;

package/lib/types/Locale.js

@@ -910,6 +910,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Check Modifier": null,
                 "spells.traditions.general": null,
                 "magicalactions.animistforces.tribes.general": null,
+                // Skill check modifiers
                 " (modified by {$modifier})": null,
                 " (−{$modifier})": null,
                 "{$first} or {$second}, depending on which value is higher": null,
@@ -917,6 +918,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 "ID": null,
                 "Creation Difficulty": null,
                 "CD": null,
+                "Object": null,
                 "Effect": null,
                 "Casting Time": null,
                 "Ritual Time": null,
@@ -1045,8 +1047,10 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Touch": null,
                 "Radius": null,
                 " (casting)": null,
+                // Target Category
                 "Zone": null,
                 "Liturgical Chants and Ceremonies": null,
+                "Spellworks": null,
                 "General": null,
                 "Note": null,
                 "all": null,
@@ -1082,6 +1086,10 @@ export const Locale = DB.Entity(import.meta.url, {
                 "domain {$domain}": null,
                 "{$pact} level {$pactLevel}": null,
                 "Level {$level}:": null,
+                // Personality Trait prerequisite
+                ".input {$level :number} {{Level {$level}}}": null,
+                "cannot be chosen at the same time as {$trait}": null,
+                "must have {$trait}": null,
                 "inlinewiki.castingtime": null,
                 "inlinewiki.ritualtime": null,
                 "inlinewiki.aecost": null,
@@ -1282,6 +1290,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Critical Success": null,
                 "Botch": null,
                 "Improvement Cost": null,
+                // Source References
                 "Front Cover Inside": null,
                 "Back Cover Inside": null,
                 ".input {$printing :number} {{since the {$printing}. printing}}": null,

package/lib/types/MetaCondition.d.ts

@@ -18,7 +18,7 @@ export declare const MetaCondition: DB.Entity<"MetaCondition", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/PactCategory.d.ts

@@ -30,7 +30,7 @@ export declare const PactCategory: DB.Entity<"PactCategory", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Patron.d.ts

@@ -72,7 +72,7 @@ export declare const Patron: DB.Entity<"Patron", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/PersonalityTrait.d.ts

@@ -44,7 +44,7 @@ export declare const PersonalityTrait: DB.Entity<"PersonalityTrait", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Profession.d.ts

@@ -601,7 +601,7 @@ export declare const Profession: DB.Entity<"Profession", {
                         }, []>>, false>;
                     }>, []>>>, true>;
                     isRemoved: DB.MemberDecl<DB.Boolean, false>;
-                }>, []>>, false>;
+                }>, []>>, true>;
                 revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                     Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                         printing: DB.MemberDecl<DB.Integer, true>;
@@ -1241,7 +1241,7 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Race.d.ts

@@ -116,7 +116,7 @@ export declare const Race: DB.Entity<"Race", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Ritual.d.ts

@@ -533,7 +533,7 @@ export declare const Ritual: DB.Entity<"Ritual", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;
@@ -646,7 +646,7 @@ export declare const Ritual: DB.Entity<"Ritual", {
                         }, []>>, false>;
                     }>, []>>>, true>;
                     isRemoved: DB.MemberDecl<DB.Boolean, false>;
-                }>, []>>, false>;
+                }>, []>>, true>;
                 revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                     Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                         printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Service.d.ts

@@ -22,7 +22,7 @@ export declare const Service: DB.Entity<"Service", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/SexPractice.d.ts

@@ -18,7 +18,7 @@ export declare const SexPractice: DB.Entity<"SexPractice", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;