@optolith/database-schema 0.104.0 → 0.106.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 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.106.0](https://github.com/Optolith/database-schema/compare/v0.105.0...v0.106.0) (2026-10-16)
+
+### ⚠ BREAKING CHANGES
+
+* allow blessed tradition groups as associated traditions for ceremonial items
+
+### Features
+
+* allow blessed tradition groups as associated traditions for ceremonial items ([315ddc7](https://github.com/Optolith/database-schema/commit/315ddc7a46ca48511ecee0c448fe0f691a1bc165))
+
+## [0.105.0](https://github.com/Optolith/database-schema/compare/v0.104.0...v0.105.0) (2026-10-16)
+
+### ⚠ BREAKING CHANGES
+
+* aspects by tradition for ceremonial item special abilities
+* rename unbreakable to indestructible
+
+### Features
+
+* aspects by tradition for ceremonial item special abilities ([6f64bed](https://github.com/Optolith/database-schema/commit/6f64bedbcac3874f8ccd331773a2a0c2b76513a1))
+
+### Bug Fixes
+
+* rename unbreakable to indestructible ([4fcd4d3](https://github.com/Optolith/database-schema/commit/4fcd4d31f555ee7f22eaba77a2e12c9ccd3c3cf9))
+
 ## [0.104.0](https://github.com/Optolith/database-schema/compare/v0.103.2...v0.104.0) (2026-10-15)
 
 ### ⚠ BREAKING CHANGES

package/gen/types.d.ts

@@ -286,6 +286,7 @@ export type EnumMap = {
   CantripRange: CantripRange
   CastingTime: CastingTime<unknown>
   CastingTimeDuringLovemakingUnit: CastingTimeDuringLovemakingUnit
+  CeremonialItemSpecialAbilityAspect: CeremonialItemSpecialAbilityAspect
   CheckResultArithmetic: CheckResultArithmetic
   ChildEntityForSelectOption: ChildEntityForSelectOption
   CollectorsValue: CollectorsValue
@@ -604,6 +605,7 @@ export type TypeAliasMap = {
   CastingTimeDuringLovemaking: CastingTimeDuringLovemaking
   CastingTimeIncludingLovemaking: CastingTimeIncludingLovemaking<unknown>
   Cause: Cause
+  CeremonialItemSpecialAbilityAspectByTradition: CeremonialItemSpecialAbilityAspectByTradition
   CheckResultBasedModifier: CheckResultBasedModifier
   ChildNode: ChildNode
   ChildSelectOptionRuleValue: ChildSelectOptionRuleValue
@@ -956,6 +958,7 @@ export type TypeAliasMap = {
   ShamanisticBlessedTradition: ShamanisticBlessedTradition
   Since: Since
   SingleBannzeichenCost: SingleBannzeichenCost
+  SingleCeremonialItemSpecialAbilityAspect: SingleCeremonialItemSpecialAbilityAspect
   SingleCommonnessRatedAdvantageDisadvantage: SingleCommonnessRatedAdvantageDisadvantage<unknown>
   SingleCommonnessRatedAdvantageDisadvantageInGroup: SingleCommonnessRatedAdvantageDisadvantageInGroup<unknown>
   SingleDerivedCharacteristicSkillCheckPenalty: SingleDerivedCharacteristicSkillCheckPenalty
@@ -2701,7 +2704,7 @@ export interface Locale {
     "Medium Shield": string
     "Small Shield": string
     "{$value} structure points": string & { __params: { "value": string } }
-    "unbreakable": string
+    "indestructible": string
     "additional {$value} AT for main weapon": string & { __params: { "value": string } }
     "Price": string
     "all armor": string
@@ -12782,11 +12785,11 @@ export interface ComplexComplexity {
 }
 
 /**
- * The structure points of the item. Use an array if the item consists of multiple components that have individual structure points. The item may also be declared as unbreakable, in which case the item has no structure points.
+ * The structure points of the item. Use an array if the item consists of multiple components that have individual structure points. The item may also be declared as indestructible, in which case the item has no structure points.
  */
 export type StructurePoints =
   | {
-    kind: "Unbreakable"
+    kind: "Indestructible"
   }
   | {
     kind: "Points"
@@ -13634,7 +13637,7 @@ export interface CeremonialItemSpecialAbility {
   /**
    * The blessed aspect.
    */
-  aspect?: Aspect_ID
+  aspect?: CeremonialItemSpecialAbilityAspect
 
   prerequisites?: GeneralPrerequisites
 
@@ -13718,6 +13721,26 @@ export interface CeremonialItemSpecialAbilityGroupTranslation {
   nameForSorting: string
 }
 
+export type CeremonialItemSpecialAbilityAspect =
+  | {
+    kind: "Single"
+    Single: SingleCeremonialItemSpecialAbilityAspect
+  }
+  | {
+    kind: "ByTradition"
+    ByTradition: CeremonialItemSpecialAbilityAspectByTradition
+  }
+
+export type SingleCeremonialItemSpecialAbilityAspect = Aspect_ID
+
+export type CeremonialItemSpecialAbilityAspectByTradition = {
+  [blessedTraditionId: string]: CeremonialItemSpecialAbilityAspectForTradition
+}
+
+export interface CeremonialItemSpecialAbilityAspectForTradition {
+  aspect: Aspect_ID
+}
+
 export interface ChronicleEnchantment {
   /**
    * Number of available levels.
@@ -24938,7 +24961,7 @@ export interface CeremonialItem {
   /**
    * The deity associated with the equipment item.
    */
-  associated_tradition: BlessedTradition_ID
+  associated_tradition: RestrictedToBlessedTraditionsScope
 
   /**
    * The item can also be used either as an improvised weapon or as an armor, although this is not the primary use case of the item.

package/lib/types/Locale.d.ts

@@ -1511,7 +1511,7 @@ export declare const Locale: DB.Entity<"Locale", {
         "Medium Shield": null;
         "Small Shield": null;
         "{$value} structure points": null;
-        unbreakable: null;
+        indestructible: null;
         "additional {$value} AT for main weapon": null;
         Price: null;
         "all armor": null;

package/lib/types/Locale.js

@@ -1553,7 +1553,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Medium Shield": null,
                 "Small Shield": null,
                 "{$value} structure points": null,
-                "unbreakable": null,
+                "indestructible": null,
                 "additional {$value} AT for main weapon": null,
                 "Price": null,
                 "all armor": null,

package/lib/types/_ActivatableNonMundane.d.ts

@@ -471,4 +471,3 @@ export declare const propertyOptional: () => DB.MemberDecl<DB.IncludeIdentifier<
     Fixed: DB.EnumCase<DB.ReferenceIdentifier>;
 }, []>>, false>;
 export declare const aspect: () => DB.MemberDecl<DB.ReferenceIdentifier, true>;
-export declare const aspectOptional: () => DB.MemberDecl<DB.ReferenceIdentifier, false>;

package/lib/types/_ActivatableNonMundane.js

@@ -479,7 +479,3 @@ export const aspect = () => DB.Required({
     comment: "The blessed aspect.",
     type: AspectIdentifier(),
 });
-export const aspectOptional = () => DB.Optional({
-    comment: "The blessed aspect.",
-    type: AspectIdentifier(),
-});

package/lib/types/equipment/item/ArmorAccessory.d.ts

@@ -96,7 +96,7 @@ export declare const ArmorAccessory: DB.Entity<"ArmorAccessory", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/BandageOrRemedy.d.ts

@@ -96,7 +96,7 @@ export declare const BandageOrRemedy: DB.Entity<"BandageOrRemedy", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/Book.d.ts

@@ -183,7 +183,7 @@ export declare const Book: DB.Entity<"Book", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/CeremonialItem.d.ts

@@ -96,12 +96,16 @@ export declare const CeremonialItem: DB.Entity<"CeremonialItem", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;
     }, []>>, false>;
-    associated_tradition: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    associated_tradition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedToBlessedTraditionsScope", {
+        Specific: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
+        Church: DB.EnumCase<null>;
+        Shamanistic: DB.EnumCase<null>;
+    }, []>>, true>;
     combat_use: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CombatUse", {
         Weapon: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ImprovisedWeapon", DB.Object<{
             melee_uses: DB.MemberDecl<DB.NestedEntityMap<string, {

package/lib/types/equipment/item/CeremonialItem.js

@@ -1,7 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
-import { BlessedTraditionIdentifier } from "../../_Identifier.js";
 import { src } from "../../source/_PublicationRef.js";
-import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { CombatUse, Complexity, Cost, DefaultItemTranslations, RestrictedToBlessedTraditionsScope, StructurePoints, Weight, } from "./_Item.js";
 import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const CeremonialItem = DB.Entity(import.meta.url, {
     name: "CeremonialItem",
@@ -25,7 +24,7 @@ export const CeremonialItem = DB.Entity(import.meta.url, {
         }),
         associated_tradition: DB.Required({
             comment: "The deity associated with the equipment item.",
-            type: BlessedTraditionIdentifier(),
+            type: DB.IncludeIdentifier(RestrictedToBlessedTraditionsScope),
         }),
         combat_use: DB.Optional({
             comment: "The item can also be used either as an improvised weapon or as an armor, although this is not the primary use case of the item.",

package/lib/types/equipment/item/Clothes.d.ts

@@ -96,7 +96,7 @@ export declare const Clothes: DB.Entity<"Clothes", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/Container.d.ts

@@ -96,7 +96,7 @@ export declare const Container: DB.Entity<"Container", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/EquipmentOfBlessedOnes.d.ts

@@ -23,7 +23,7 @@ export declare const EquipmentOfBlessedOnes: DB.Entity<"EquipmentOfBlessedOnes",
         }>, []>>>;
     }, []>>, true>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/IlluminationLightSource.d.ts

@@ -96,7 +96,7 @@ export declare const IlluminationLightSource: DB.Entity<"IlluminationLightSource
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/IlluminationRefillOrSupply.d.ts

@@ -96,7 +96,7 @@ export declare const IlluminationRefillOrSupply: DB.Entity<"IlluminationRefillOr
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/Item.d.ts

@@ -97,7 +97,7 @@ export declare const Item: DB.Entity<"Item", {
         }>, []>>>;
     }, []>>, false>;
     structurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/Jewelry.d.ts

@@ -83,7 +83,7 @@ export declare const Jewelry: DB.Entity<"Jewelry", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/Liebesspielzeug.d.ts

@@ -96,7 +96,7 @@ export declare const Liebesspielzeug: DB.Entity<"Liebesspielzeug", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/LuxuryGood.d.ts

@@ -96,7 +96,7 @@ export declare const LuxuryGood: DB.Entity<"LuxuryGood", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/MagicalArtifact.d.ts

@@ -96,7 +96,7 @@ export declare const MagicalArtifact: DB.Entity<"MagicalArtifact", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/MusicalInstrument.d.ts

@@ -96,7 +96,7 @@ export declare const MusicalInstrument: DB.Entity<"MusicalInstrument", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/OrienteeringAid.d.ts

@@ -95,7 +95,7 @@ export declare const OrienteeringAid: import("tsondb/schema/dsl").Entity<string,
         }>, []>>>;
     }, []>>, false>;
     structure_points: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"StructurePoints", {
-        Unbreakable: import("tsondb/schema/dsl").EnumCase<null>;
+        Indestructible: import("tsondb/schema/dsl").EnumCase<null>;
         Points: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StructurePointsPoints", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StructurePointsComponent", import("tsondb/schema/dsl").Object<{
             points: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/RopeOrChain.d.ts

@@ -95,7 +95,7 @@ export declare const RopeOrChain: import("tsondb/schema/dsl").Entity<string, {
         }>, []>>>;
     }, []>>, false>;
     structure_points: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"StructurePoints", {
-        Unbreakable: import("tsondb/schema/dsl").EnumCase<null>;
+        Indestructible: import("tsondb/schema/dsl").EnumCase<null>;
         Points: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StructurePointsPoints", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StructurePointsComponent", import("tsondb/schema/dsl").Object<{
             points: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/Stationery.d.ts

@@ -95,7 +95,7 @@ export declare const Stationery: import("tsondb/schema/dsl").Entity<string, {
         }>, []>>>;
     }, []>>, false>;
     structure_points: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"StructurePoints", {
-        Unbreakable: import("tsondb/schema/dsl").EnumCase<null>;
+        Indestructible: import("tsondb/schema/dsl").EnumCase<null>;
         Points: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StructurePointsPoints", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StructurePointsComponent", import("tsondb/schema/dsl").Object<{
             points: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/ThievesTool.d.ts

@@ -95,7 +95,7 @@ export declare const ThievesTool: import("tsondb/schema/dsl").Entity<string, {
         }>, []>>>;
     }, []>>, false>;
     structure_points: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"StructurePoints", {
-        Unbreakable: import("tsondb/schema/dsl").EnumCase<null>;
+        Indestructible: import("tsondb/schema/dsl").EnumCase<null>;
         Points: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StructurePointsPoints", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StructurePointsComponent", import("tsondb/schema/dsl").Object<{
             points: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/ToolOfTheTrade.d.ts

@@ -96,7 +96,7 @@ export declare const ToolOfTheTrade: DB.Entity<"ToolOfTheTrade", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/TravelGearOrTool.d.ts

@@ -96,7 +96,7 @@ export declare const TravelGearOrTool: DB.Entity<"TravelGearOrTool", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/Weapon.d.ts

@@ -96,7 +96,7 @@ export declare const Weapon: DB.Entity<"Weapon", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/WeaponAccessory.d.ts

@@ -96,7 +96,7 @@ export declare const WeaponAccessory: DB.Entity<"WeaponAccessory", {
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;

package/lib/types/equipment/item/_Item.d.ts

@@ -96,7 +96,7 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
         }>, []>>>;
     }, []>>, false>;
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"StructurePoints", {
-        Unbreakable: DB.EnumCase<null>;
+        Indestructible: DB.EnumCase<null>;
         Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;
@@ -504,7 +504,7 @@ export declare const CombatUse: DB.Enum<"CombatUse", {
     }>, []>>>;
 }, []>;
 export declare const StructurePoints: DB.Enum<"StructurePoints", {
-    Unbreakable: DB.EnumCase<null>;
+    Indestructible: DB.EnumCase<null>;
     Points: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsPoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
         points: DB.MemberDecl<DB.Integer, true>;
     }>, []>>>, []>>>;

package/lib/types/equipment/item/_Item.js

@@ -85,9 +85,9 @@ export const CombatUse = DB.Enum(import.meta.url, {
 });
 export const StructurePoints = DB.Enum(import.meta.url, {
     name: "StructurePoints",
-    comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points. The item may also be declared as unbreakable, in which case the item has no structure points.",
+    comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points. The item may also be declared as indestructible, in which case the item has no structure points.",
     values: () => ({
-        Unbreakable: DB.EnumCase({ type: null }),
+        Indestructible: DB.EnumCase({ type: null }),
         Points: DB.EnumCase({ type: DB.IncludeIdentifier(StructurePointsPoints) }),
     }),
 });

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

@@ -1125,7 +1125,12 @@ export declare const CeremonialItemSpecialAbility: DB.Entity<"CeremonialItemSpec
         }>, false>;
     }, "parent">>, true>;
     maximum: DB.MemberDecl<DB.Integer, false>;
-    aspect: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+    aspect: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CeremonialItemSpecialAbilityAspect", {
+        Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleCeremonialItemSpecialAbilityAspect", DB.ReferenceIdentifier, []>>>;
+        ByTradition: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CeremonialItemSpecialAbilityAspectByTradition", DB.NestedEntityMap<string, {
+            aspect: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        }>, []>>>;
+    }, []>>, false>;
     prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"GeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesForLevels", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteForLevel", DB.Object<{
         level: DB.MemberDecl<DB.Integer, true>;
         prerequisite: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {

package/lib/types/specialAbility/CeremonialItemSpecialAbility.js

@@ -2,14 +2,14 @@ import * as DB from "tsondb/schema/dsl";
 import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
 import { nameBuilderRules } from "../_ActivatableNames.js";
-import { aspectOptional } from "../_ActivatableNonMundane.js";
 import { explicit_select_options, select_options, verifySelectOptionRules, } from "../_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js";
-import { CeremonialItemSpecialAbilityGroupIdentifier } from "../_Identifier.js";
+import { AspectIdentifier, CeremonialItemSpecialAbilityGroupIdentifier } from "../_Identifier.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
 import { NestedTranslationMap } from "../Locale.js";
 import { Errata } from "../source/_Erratum.js";
 import { src } from "../source/_PublicationRef.js";
+import { BlessedTradition } from "./BlessedTradition.js";
 export const CeremonialItemSpecialAbility = DB.Entity(import.meta.url, {
     name: "CeremonialItemSpecialAbility",
     namePlural: "CeremonialItemSpecialAbilities",
@@ -24,7 +24,10 @@ export const CeremonialItemSpecialAbility = DB.Entity(import.meta.url, {
         skill_applications,
         skill_uses,
         maximum,
-        aspect: aspectOptional(),
+        aspect: DB.Optional({
+            comment: "The blessed aspect.",
+            type: DB.IncludeIdentifier(CeremonialItemSpecialAbilityAspect),
+        }),
         prerequisites: DB.Optional({
             type: DB.IncludeIdentifier(GeneralPrerequisites),
         }),
@@ -79,3 +82,27 @@ export const CeremonialItemSpecialAbility = DB.Entity(import.meta.url, {
     ],
     customConstraints: deps => verifySelectOptionRules("CeremonialItemSpecialAbility", deps),
 });
+const CeremonialItemSpecialAbilityAspect = DB.Enum(import.meta.url, {
+    name: "CeremonialItemSpecialAbilityAspect",
+    values: () => ({
+        Single: DB.EnumCase({ type: DB.IncludeIdentifier(SingleCeremonialItemSpecialAbilityAspect) }),
+        ByTradition: DB.EnumCase({
+            type: DB.IncludeIdentifier(CeremonialItemSpecialAbilityAspectByTradition),
+        }),
+    }),
+});
+const SingleCeremonialItemSpecialAbilityAspect = DB.TypeAlias(import.meta.url, {
+    name: "SingleCeremonialItemSpecialAbilityAspect",
+    type: () => AspectIdentifier(),
+});
+const CeremonialItemSpecialAbilityAspectByTradition = DB.TypeAlias(import.meta.url, {
+    name: "CeremonialItemSpecialAbilityAspectByTradition",
+    type: () => DB.NestedEntityMap({
+        name: "CeremonialItemSpecialAbilityAspectForTradition",
+        namePlural: "CeremonialItemSpecialAbilityAspectForTraditions",
+        secondaryEntity: BlessedTradition,
+        type: DB.Object({
+            aspect: DB.Required({ type: AspectIdentifier() }),
+        }),
+    }),
+});

package/package.json

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