@optolith/database-schema 0.87.0 → 0.89.0

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.89.0](https://github.com/Optolith/database-schema/compare/v0.88.0...v0.89.0) (2026-10-09)
+
+### ⚠ BREAKING CHANGES
+
+* blessed tradition groups in cultures
+
+### Features
+
+* blessed tradition groups in cultures ([6a1cc80](https://github.com/Optolith/database-schema/commit/6a1cc805a8f32c32e993fcc6a1226a3aa16daa30))
+* name of people in culture ([1b9fbcf](https://github.com/Optolith/database-schema/commit/1b9fbcfbfbf24a46f73ac8c14959d5c57bc9f317))
+
+## [0.88.0](https://github.com/Optolith/database-schema/compare/v0.87.0...v0.88.0) (2026-10-08)
+
+### ⚠ BREAKING CHANGES
+
+* separate religious profession group
+
+### Features
+
+* separate religious profession group ([5058757](https://github.com/Optolith/database-schema/commit/50587570cb9bf4418b80048c604dac83adf2431f))
+
 ## [0.87.0](https://github.com/Optolith/database-schema/compare/v0.86.0...v0.87.0) (2026-10-07)
 
 ### ⚠ BREAKING CHANGES

package/gen/types.d.ts

@@ -30,6 +30,7 @@ export type EntityMap = {
   Beutelzauber: Beutelzauber
   Biome: Biome
   BlessedTradition: BlessedTradition
+  BlessedTraditionGroup: BlessedTraditionGroup
   Blessing: Blessing
   Book: Book
   BotanicRegion: BotanicRegion
@@ -563,6 +564,7 @@ export type TypeAliasMap = {
   BindingCostMapOptionValue: BindingCostMapOptionValue
   BindingCostPerLevel: BindingCostPerLevel
   BlessedTraditionConstraint: BlessedTraditionConstraint
+  BlessedTraditionGroupConstraint: BlessedTraditionGroupConstraint
   BlessedTraditionPrerequisite: BlessedTraditionPrerequisite
   BlessedTraditionsSelectOptionCategory: BlessedTraditionsSelectOptionCategory
   BlessingPerformanceParameters: BlessingPerformanceParameters
@@ -883,6 +885,7 @@ export type TypeAliasMap = {
   ReferenceListNode: ReferenceListNode
   ReferenceListNodeImprovementCostSource: ReferenceListNodeImprovementCostSource
   ReferenceNode: ReferenceNode
+  ReligiousProfessionGroup: ReligiousProfessionGroup
   ReloadTime: ReloadTime
   ReplacementDisplayOption: ReplacementDisplayOption
   RequiredMinimumSkillsToBeOnSkillRating: RequiredMinimumSkillsToBeOnSkillRating
@@ -7854,6 +7857,11 @@ export interface LiturgyTraditionWithAspects {
 }
 
 export interface BlessedTradition {
+  /**
+   * The group of traditions this tradition belongs to.
+   */
+  group: BlessedTraditionGroup_ID
+
   /**
    * Definitions for possible options for the activatable entry, derived from entry categories.
    * 
@@ -7972,6 +7980,32 @@ export interface BlessedTraditionTranslation {
   errata?: Errata
 }
 
+export interface BlessedTraditionGroup {
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: BlessedTraditionGroupTranslation
+  }
+}
+
+/**
+ * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
+ */
+export type BlessedTraditionGroup_ID = string
+
+export interface BlessedTraditionGroupTranslation {
+  /**
+   * The name of the group.
+   */
+  name: string
+
+  /**
+   * The text to use when all Blessed Ones of this group are recommended for a culture.
+   */
+  nameInCulture: string
+}
+
 export interface Blessing {
   /**
    * Measurable parameters of a blessing.
@@ -8912,6 +8946,10 @@ export type ProfessionGroup =
   | {
     kind: "Blessed"
   }
+  | {
+    kind: "Religious"
+    Religious: ReligiousProfessionGroup
+  }
 
 export type MundaneProfessionGroup =
   | {
@@ -8920,9 +8958,6 @@ export type MundaneProfessionGroup =
   | {
     kind: "Fighter"
   }
-  | {
-    kind: "Religious"
-  }
 
 export interface MagicalProfessionGroup {
   /**
@@ -9518,6 +9553,13 @@ export interface SpellworkAdjustmentWithBase {
   tradition?: MagicalTradition_ID
 }
 
+export interface ReligiousProfessionGroup {
+  /**
+   * The associated blessed tradition (religion).
+   */
+  associatedTradition?: BlessedTradition_ID
+}
+
 export interface ProfessionVersion {
   /**
    * The associated profession.
@@ -9856,6 +9898,11 @@ export interface CultureTranslation {
    */
   nameInPrerequisites?: string
 
+  /**
+   * The name for people of this culture, if different from the normal culture’s name.
+   */
+  nameOfPeople?: string
+
   /**
    * The description of the area knowledge.
    */
@@ -10067,10 +10114,6 @@ export type MundaneCommonProfessionConstraint =
     kind: "Profession"
     Profession: ProfessionConstraint
   }
-  | {
-    kind: "Group"
-    Group: MundaneProfessionGroup
-  }
 
 export interface ProfessionConstraint {
   /**
@@ -10114,6 +10157,9 @@ export type CommonnessWeight =
   | {
     kind: "Only"
   }
+  | {
+    kind: "ExceptFor"
+  }
 
 export interface ProfessionVariant {
   /**
@@ -21232,6 +21278,13 @@ export type BlessedCommonProfessionConstraint =
     kind: "Profession"
     Profession: ProfessionConstraint
   }
+  | {
+    kind: "Group"
+    Group: BlessedTraditionGroupConstraint
+  }
+  | {
+    kind: "Religious"
+  }
 
 export interface BlessedTraditionConstraint {
   /**
@@ -21250,6 +21303,23 @@ export interface BlessedTraditionConstraint {
   rarity?: Rarity
 }
 
+export interface BlessedTraditionGroupConstraint {
+  /**
+   * The blessed tradition group’s identifier.
+   */
+  id: BlessedTraditionGroup_ID
+
+  /**
+   * Some traditions are more common than others. There may be cultures where some traditions are not represented at all.
+   */
+  weighted_professions?: Weighted<BlessedTradition_ID>
+
+  /**
+   * Some traditions may be found in a culture, but are not that common.
+   */
+  rarity?: Rarity
+}
+
 /**
  * Reference to a commonness-rated advantage or disadvantage. Commonness-rating terms used in the source books are strongly recommended, common, uncommon, suggested and unsuitable.
  */

package/lib/main.js

@@ -29,6 +29,7 @@ export const schema = new Schema([
     Types.Beutelzauber,
     Types.Biome,
     Types.BlessedTradition,
+    Types.BlessedTraditionGroup,
     Types.Blessing,
     Types.Book,
     Types.BotanicRegion,

package/lib/types/Culture.d.ts

@@ -243,6 +243,7 @@ export declare const Culture: DB.Entity<"Culture", {
     translations: DB.MemberDecl<DB.NestedEntityMap<"CultureTranslation", {
         name: DB.MemberDecl<DB.String, true>;
         nameInPrerequisites: DB.MemberDecl<DB.String, false>;
+        nameOfPeople: DB.MemberDecl<DB.String, false>;
         area_knowledge: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AreaKnowledgeTranslation", DB.Object<{
             description: DB.MemberDecl<DB.String, true>;
             abbreviated: DB.MemberDecl<DB.String, true>;

package/lib/types/Culture.js

@@ -1,9 +1,8 @@
 import * as DB from "tsondb/schema/dsl";
 import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantageDisadvantage.js";
-import { AdvantageIdentifier, BlessedTraditionIdentifier, DisadvantageIdentifier, LanguageIdentifier, LanguageSpecializationIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, ProfessionVariantIdentifier, ScriptIdentifier, SkillIdentifier, SocialStatusIdentifier, } from "./_Identifier.js";
+import { AdvantageIdentifier, BlessedTraditionGroupIdentifier, BlessedTraditionIdentifier, DisadvantageIdentifier, LanguageIdentifier, LanguageSpecializationIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, ProfessionVariantIdentifier, ScriptIdentifier, SkillIdentifier, SocialStatusIdentifier, } from "./_Identifier.js";
 import { BinarySex } from "./_Sex.js";
 import { NestedTranslationMap } from "./Locale.js";
-import { MundaneProfessionGroup } from "./Profession.js";
 import { Errata } from "./source/_Erratum.js";
 import { src } from "./source/_PublicationRef.js";
 export const Culture = DB.Entity(import.meta.url, {
@@ -68,6 +67,10 @@ export const Culture = DB.Entity(import.meta.url, {
                 comment: "The culture’s name in prerequisites, if different from the normal culture’s name.",
                 type: DB.String({ minLength: 1 }),
             }),
+            nameOfPeople: DB.Optional({
+                comment: "The name for people of this culture, if different from the normal culture’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
             area_knowledge: DB.Required({
                 comment: "The description of the area knowledge.",
                 type: DB.IncludeIdentifier(AreaKnowledgeTranslation),
@@ -145,6 +148,7 @@ const CommonnessWeight = DB.Enum(import.meta.url, {
     values: () => ({
         Mostly: DB.EnumCase({ type: null }),
         Only: DB.EnumCase({ type: null }),
+        ExceptFor: DB.EnumCase({ type: null }),
     }),
 });
 const Weighted = DB.GenTypeAlias(import.meta.url, {
@@ -244,11 +248,27 @@ const BlessedTraditionConstraint = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
+const BlessedTraditionGroupConstraint = DB.TypeAlias(import.meta.url, {
+    name: "BlessedTraditionGroupConstraint",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The blessed tradition group’s identifier.",
+            type: BlessedTraditionGroupIdentifier(),
+        }),
+        weighted_professions: DB.Optional({
+            comment: "Some traditions are more common than others. There may be cultures where some traditions are not represented at all.",
+            type: DB.GenIncludeIdentifier(Weighted, [BlessedTraditionIdentifier()]),
+        }),
+        rarity: DB.Optional({
+            comment: "Some traditions may be found in a culture, but are not that common.",
+            type: DB.IncludeIdentifier(Rarity),
+        }),
+    }),
+});
 const MundaneCommonProfessionConstraint = DB.Enum(import.meta.url, {
     name: "MundaneCommonProfessionConstraint",
     values: () => ({
         Profession: DB.EnumCase({ type: DB.IncludeIdentifier(ProfessionConstraint) }),
-        Group: DB.EnumCase({ type: DB.IncludeIdentifier(MundaneProfessionGroup) }),
     }),
 });
 const MagicCommonProfessionConstraint = DB.Enum(import.meta.url, {
@@ -264,6 +284,8 @@ const BlessedCommonProfessionConstraint = DB.Enum(import.meta.url, {
     values: () => ({
         Tradition: DB.EnumCase({ type: DB.IncludeIdentifier(BlessedTraditionConstraint) }),
         Profession: DB.EnumCase({ type: DB.IncludeIdentifier(ProfessionConstraint) }),
+        Group: DB.EnumCase({ type: DB.IncludeIdentifier(BlessedTraditionGroupConstraint) }),
+        Religious: DB.EnumCase({ type: null }),
     }),
 });
 const PlainCommonProfessions = DB.TypeAlias(import.meta.url, {

package/lib/types/Profession.d.ts

@@ -4,13 +4,15 @@ export declare const Profession: DB.Entity<"Profession", {
         Mundane: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"MundaneProfessionGroup", {
             Profane: DB.EnumCase<null>;
             Fighter: DB.EnumCase<null>;
-            Religious: DB.EnumCase<null>;
         }, []>>>;
         Magical: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MagicalProfessionGroup", DB.Object<{
             curriculum: DB.MemberDecl<DB.ReferenceIdentifier, false>;
             subgroup: DB.MemberDecl<DB.ReferenceIdentifier, false>;
         }>, []>>>;
         Blessed: DB.EnumCase<null>;
+        Religious: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReligiousProfessionGroup", DB.Object<{
+            associatedTradition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+        }>, []>>>;
     }, []>>, true>;
     versions: DB.MemberDecl<DB.ChildEntities<DB.Entity<"ProfessionVersion", {
         profession: DB.MemberDecl<DB.ReferenceIdentifier, true>;
@@ -878,7 +880,6 @@ export declare const Profession: DB.Entity<"Profession", {
 export declare const MundaneProfessionGroup: DB.Enum<"MundaneProfessionGroup", {
     Profane: DB.EnumCase<null>;
     Fighter: DB.EnumCase<null>;
-    Religious: DB.EnumCase<null>;
 }, []>;
 export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
     profession: DB.MemberDecl<DB.ReferenceIdentifier, true>;

package/lib/types/Profession.js

@@ -2,7 +2,7 @@ import { isNotNullish } from "@elyukai/utils/nullable";
 import * as DB from "tsondb/schema/dsl";
 import { verifyOptionsForActivatableEntry } from "./_ActivatableSelectOptions.js";
 import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantageDisadvantage.js";
-import { AdvantageIdentifier, BannzeichenOptionIdentifier, CantripIdentifier, CurriculumIdentifier, DisadvantageIdentifier, ExperienceLevelIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, ProfessionPackageIdentifier, ProfessionVersionIdentifier, SkillGroupIdentifier, SkillIdentifier, } from "./_Identifier.js";
+import { AdvantageIdentifier, BannzeichenOptionIdentifier, BlessedTraditionIdentifier, CantripIdentifier, CurriculumIdentifier, DisadvantageIdentifier, ExperienceLevelIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, ProfessionPackageIdentifier, ProfessionVersionIdentifier, SkillGroupIdentifier, SkillIdentifier, } from "./_Identifier.js";
 import { CombatTechniqueIdentifier, LiturgyIdentifier, MagicalActionIdentifier, ProfessionSpecialAbilityIdentifier, RequirableSelectOptionIdentifier, SpecialAbilityIdentifier, SpellworkIdentifier, } from "./_IdentifierGroup.js";
 import { ProfessionPrerequisites, ProfessionVariantPrerequisites } from "./_Prerequisite.js";
 import { NestedTranslationMap } from "./Locale.js";
@@ -47,6 +47,7 @@ const ProfessionGroup = DB.Enum(import.meta.url, {
         Mundane: DB.EnumCase({ type: DB.IncludeIdentifier(MundaneProfessionGroup) }),
         Magical: DB.EnumCase({ type: DB.IncludeIdentifier(MagicalProfessionGroup) }),
         Blessed: DB.EnumCase({ type: null }),
+        Religious: DB.EnumCase({ type: DB.IncludeIdentifier(ReligiousProfessionGroup) }),
     }),
 });
 export const MundaneProfessionGroup = DB.Enum(import.meta.url, {
@@ -54,7 +55,6 @@ export const MundaneProfessionGroup = DB.Enum(import.meta.url, {
     values: () => ({
         Profane: DB.EnumCase({ type: null }),
         Fighter: DB.EnumCase({ type: null }),
-        Religious: DB.EnumCase({ type: null }),
     }),
 });
 const MagicalProfessionGroup = DB.TypeAlias(import.meta.url, {
@@ -70,6 +70,15 @@ const MagicalProfessionGroup = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
+const ReligiousProfessionGroup = DB.TypeAlias(import.meta.url, {
+    name: "ReligiousProfessionGroup",
+    type: () => DB.Object({
+        associatedTradition: DB.Optional({
+            comment: "The associated blessed tradition (religion).",
+            type: BlessedTraditionIdentifier(),
+        }),
+    }),
+});
 export const ProfessionVersion = DB.Entity(import.meta.url, {
     name: "ProfessionVersion",
     namePlural: "ProfessionVersions",

package/lib/types/_Identifier.d.ts

@@ -27,6 +27,7 @@ export declare const BannzeichenOptionIdentifier: () => R;
 export declare const BeutelzauberIdentifier: () => R;
 export declare const BiomeIdentifier: () => R;
 export declare const BlessedTraditionIdentifier: () => R;
+export declare const BlessedTraditionGroupIdentifier: () => R;
 export declare const BlessingIdentifier: () => R;
 export declare const BookIdentifier: () => R;
 export declare const BowlEnchantmentIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -128,6 +128,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 { BlessedTraditionGroup } from "./specialAbility/sub/BlessedTraditionGroup.js";
 import { CeremonialItemSpecialAbilityGroup } from "./specialAbility/sub/CeremonialItemSpecialAbilityGroup.js";
 import { Language, LanguageSpecialization } from "./specialAbility/sub/Language.js";
 import { MagicalTraditionSubgroup } from "./specialAbility/sub/MagicalTraditionSubgroup.js";
@@ -194,6 +195,7 @@ export const BannzeichenOptionIdentifier = () => R(BannzeichenOption);
 export const BeutelzauberIdentifier = () => R(Beutelzauber);
 export const BiomeIdentifier = () => R(Biome);
 export const BlessedTraditionIdentifier = () => R(BlessedTradition);
+export const BlessedTraditionGroupIdentifier = () => R(BlessedTraditionGroup);
 export const BlessingIdentifier = () => R(Blessing);
 export const BookIdentifier = () => R(Book);
 export const BowlEnchantmentIdentifier = () => R(BowlEnchantment);

package/lib/types/index.d.ts

@@ -132,6 +132,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 { BlessedTraditionGroup } from "./specialAbility/sub/BlessedTraditionGroup.ts";
 export { CeremonialItemSpecialAbilityGroup } from "./specialAbility/sub/CeremonialItemSpecialAbilityGroup.js";
 export { Language } from "./specialAbility/sub/Language.js";
 export { MagicalTraditionSubgroup } from "./specialAbility/sub/MagicalTraditionSubgroup.ts";

package/lib/types/index.js

@@ -132,6 +132,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 { BlessedTraditionGroup } from "./specialAbility/sub/BlessedTraditionGroup.js";
 export { CeremonialItemSpecialAbilityGroup } from "./specialAbility/sub/CeremonialItemSpecialAbilityGroup.js";
 export { Language } from "./specialAbility/sub/Language.js";
 export { MagicalTraditionSubgroup } from "./specialAbility/sub/MagicalTraditionSubgroup.js";

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

@@ -1,5 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const BlessedTradition: DB.Entity<"BlessedTradition", {
+    group: DB.MemberDecl<DB.ReferenceIdentifier, true>;
     select_options: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptions", DB.Object<{
         derived: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionCategory", {
             Blessings: DB.EnumCase<null>;

package/lib/types/specialAbility/BlessedTradition.js

@@ -4,7 +4,7 @@ import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventu
 import { activatableDisplayNameCustomizer } from "../_ActivatableNames.js";
 import { explicit_select_options, select_options, verifySelectOptionRules, } from "../_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js";
-import { AspectIdentifier, AttributeIdentifier, BlessingIdentifier, GeneralIdentifier, SkillIdentifier, } from "../_Identifier.js";
+import { AspectIdentifier, AttributeIdentifier, BlessedTraditionGroupIdentifier, BlessingIdentifier, GeneralIdentifier, SkillIdentifier, } from "../_Identifier.js";
 import { CombatTechniqueIdentifier } from "../_IdentifierGroup.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
 import { NestedTranslationMap } from "../Locale.js";
@@ -15,6 +15,10 @@ export const BlessedTradition = DB.Entity(import.meta.url, {
     name: "BlessedTradition",
     namePlural: "BlessedTraditions",
     type: () => DB.Object({
+        group: DB.Required({
+            comment: "The group of traditions this tradition belongs to.",
+            type: BlessedTraditionGroupIdentifier(),
+        }),
         select_options,
         explicit_select_options,
         skill_applications,

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

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

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

@@ -0,0 +1,25 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "../../Locale.js";
+export const BlessedTraditionGroup = DB.Entity(import.meta.url, {
+    name: "BlessedTraditionGroup",
+    namePlural: "BlessedTraditionGroup",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "BlessedTraditionGroup", DB.Object({
+            name: DB.Required({
+                comment: "The name of the group.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            nameInCulture: DB.Required({
+                comment: "The text to use when all Blessed Ones of this group are recommended for a culture.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/package.json

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