@optolith/database-schema 0.91.0 → 0.93.0

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 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.93.0](https://github.com/Optolith/database-schema/compare/v0.92.0...v0.93.0) (2026-10-11)
+
+### ⚠ BREAKING CHANGES
+
+* allow text option for special abilities
+* derived advantages select option category
+* optional weapon cost and weight for improvised weapons
+* remove demonic poison notes in favor of base poison notes
+
+### Features
+
+* allow text option for special abilities ([ce81dc2](https://github.com/Optolith/database-schema/commit/ce81dc248ea62c8a08d9d631b50290b173ad3571)), closes [#200](https://github.com/Optolith/database-schema/issues/200)
+* derived advantages select option category ([7e36546](https://github.com/Optolith/database-schema/commit/7e365469c4d7920528ac42a5418fa37c6406dd06)), closes [#82](https://github.com/Optolith/database-schema/issues/82)
+* optional weapon cost and weight for improvised weapons ([8941125](https://github.com/Optolith/database-schema/commit/894112599982105b46fdbb9525cb0ad13e942f6f))
+* remove demonic poison notes in favor of base poison notes ([e91b3dd](https://github.com/Optolith/database-schema/commit/e91b3ddddfd02722afa3a0affe0d49f262741dd7)), closes [#183](https://github.com/Optolith/database-schema/issues/183)
+
+## [0.92.0](https://github.com/Optolith/database-schema/compare/v0.91.0...v0.92.0) (2026-10-10)
+
+### ⚠ BREAKING CHANGES
+
+* some talismans do not have a specified or existing tradition
+
+### Features
+
+* some talismans do not have a specified or existing tradition ([faeacb1](https://github.com/Optolith/database-schema/commit/faeacb1e6d9adb083bb8560d64c7b58f72fbea77))
+
 ## [0.91.0](https://github.com/Optolith/database-schema/compare/v0.90.1...v0.91.0) (2026-10-10)
 
 ### ⚠ BREAKING CHANGES

package/gen/types.d.ts

@@ -503,6 +503,7 @@ export type TypeAliasMap = {
   AdvancedSpecialAbilityDerivedFromExternalOptionMapping: AdvancedSpecialAbilityDerivedFromExternalOptionMapping<unknown>
   AdvantageAnimalPower: AdvantageAnimalPower
   AdvantageDisadvantagePrerequisites: AdvantageDisadvantagePrerequisites
+  AdvantagesSelectOptionCategory: AdvantagesSelectOptionCategory
   AdventurePointsDependingOnActive: AdventurePointsDependingOnActive
   AdventurePointsDependingOnActiveInstancesExpression: AdventurePointsDependingOnActiveInstancesExpression
   AdventurePointsDependingOnActiveInstancesExpressionExpression: AdventurePointsDependingOnActiveInstancesExpressionExpression
@@ -602,7 +603,6 @@ export type TypeAliasMap = {
   ConstantDemonicPoisonLevel: ConstantDemonicPoisonLevel
   ConstantIntoxicantAddictionInterval: ConstantIntoxicantAddictionInterval
   ConstantMagicalSignCost: ConstantMagicalSignCost
-  ConstantProfessionSpecialAbility: ConstantProfessionSpecialAbility
   CostRange: CostRange
   CulturalPackageItem: CulturalPackageItem
   CultureLanguage: CultureLanguage
@@ -854,7 +854,7 @@ export type TypeAliasMap = {
   ProfessionPrerequisite: ProfessionPrerequisite
   ProfessionPrerequisites: ProfessionPrerequisites
   ProfessionSpecialAbilitySelection: ProfessionSpecialAbilitySelection
-  ProfessionSpecialAbilitySelectionItem: ProfessionSpecialAbilitySelectionItem
+  ProfessionSpecialAbilityTextOption: ProfessionSpecialAbilityTextOption
   ProfessionSpellworkIdentifier: ProfessionSpellworkIdentifier
   ProfessionVariantPackageOptions: ProfessionVariantPackageOptions
   ProfessionVariantPrerequisites: ProfessionVariantPrerequisites
@@ -926,6 +926,7 @@ export type TypeAliasMap = {
   SingleMagicalRuneCost: SingleMagicalRuneCost
   SinglePenalty: SinglePenalty
   SinglePrimaryAttributeDamageThreshold: SinglePrimaryAttributeDamageThreshold
+  SingleProfessionSpecialAbility: SingleProfessionSpecialAbility
   SingleResistance: SingleResistance
   SkillAdjustment: SkillAdjustment
   SkillAnimalPower: SkillAnimalPower
@@ -1259,6 +1260,10 @@ export type SelectOptionCategory =
     kind: "TargetCategories"
     TargetCategories: TargetCategoriesSelectOptionCategory
   }
+  | {
+    kind: "Advantages"
+    Advantages: AdvantagesSelectOptionCategory
+  }
 
 export interface BlessedTraditionsSelectOptionCategory {
   /**
@@ -6345,20 +6350,6 @@ export interface DemonicPoison {
    * The poison’s level.
    */
   level: DemonicPoisonLevel
-
-  /**
-   * All translations for the entry, identified by IETF language tag (BCP47).
-   */
-  translations?: {
-    [localeId: string]: DemonicPoisonTranslation
-  }
-}
-
-export interface DemonicPoisonTranslation {
-  /**
-   * A note, if any.
-   */
-  note?: string
 }
 
 export type DemonicPoisonLevel =
@@ -12545,12 +12536,12 @@ export interface Weapon {
   /**
    * The cost in silverthalers.
    */
-  cost: Cost
+  cost?: Cost
 
   /**
    * The weight in kg.
    */
-  weight: Weight
+  weight?: Weight
 
   /**
    * The complexity of crafting the item.
@@ -18633,14 +18624,14 @@ export type VariantSpecialAbilityAction =
 export type ProfessionSpecialAbility =
   | {
     kind: "Constant"
-    Constant: ConstantProfessionSpecialAbility
+    Constant: SingleProfessionSpecialAbility
   }
   | {
     kind: "Selection"
     Selection: ProfessionSpecialAbilitySelection
   }
 
-export interface ConstantProfessionSpecialAbility {
+export interface SingleProfessionSpecialAbility {
   /**
    * The identifier of the special ability to grant.
    */
@@ -18884,32 +18875,35 @@ export type ProfessionSpecialAbilityOption =
     kind: "Identifier"
     Identifier: RequirableSelectOptionIdentifier
   }
+  | {
+    kind: "Text"
+    Text: ProfessionSpecialAbilityTextOption
+  }
   | {
     kind: "Select"
   }
 
-export interface ProfessionSpecialAbilitySelection {
+export interface ProfessionSpecialAbilityTextOption {
   /**
-   * The list of special abilities to choose from. Must contain at least two entries.
+   * All translations for the entry, identified by IETF language tag (BCP47).
    */
-  options: ProfessionSpecialAbilitySelectionItem[]
+  translations: {
+    [localeId: string]: ProfessionSpecialAbilityTextOptionTranslation
+  }
 }
 
-export interface ProfessionSpecialAbilitySelectionItem {
+export interface ProfessionSpecialAbilityTextOptionTranslation {
   /**
-   * The identifier of the special ability to grant.
+   * The text of the option.
    */
-  id: ProfessionSpecialAbilityIdentifier
-
-  /**
-   * The level of the received special ability. If not specified and the special ability has levels, level 1 is used automatically.
-   */
-  level?: number
+  text: string
+}
 
+export interface ProfessionSpecialAbilitySelection {
   /**
-   * Received select options. Order is important. Typically, you only need the first array index, though.
+   * The list of special abilities to choose from. Must contain at least two entries.
    */
-  options?: RequirableSelectOptionIdentifier[]
+  options: SingleProfessionSpecialAbility[]
 }
 
 export interface CombatTechniqueRating {
@@ -23193,6 +23187,13 @@ export type AdvantageDisadvantagePrerequisiteGroup =
     PersonalityTrait: PersonalityTraitPrerequisite
   }
 
+export interface AdvantagesSelectOptionCategory {
+  /**
+   * A list of advantages of which the generated advantages must depend on at least one of them each.
+   */
+  dependingOn: Advantage_ID[]
+}
+
 /**
  * Rules for how options can be selected and relate to each other. Defaults to a single predefined option if the entry has select options defined, otherwise undefined.
  */
@@ -27938,7 +27939,7 @@ export interface Talisman {
   /**
    * The tradition(s) the talisman belongs to.
    */
-  tradition: BlessedTradition_ID[]
+  tradition?: BlessedTradition_ID[]
 
   /**
    * The talisman type, if any.

package/lib/cache/activatableSelectOptions.d.ts

@@ -2,7 +2,7 @@ import { Case } from "tsondb/schema/gen";
 import type { ActivatableIdentifier as ActivatableIdentifierType, GeneralSelectOption, RequirableSelectOptionIdentifier, TradeSecretAdventurePointsValue } from "../../gen/types.js";
 import type { CacheBuilder } from "./internal.ts";
 import type { ResolvedNewSkillApplication, ResolvedSkillUse } from "./newApplicationsAndUses.ts";
-export type ResolvedSelectOptionIdentifier = RequirableSelectOptionIdentifier | Case<"Blessing" | "Cantrip" | "Script" | "Culture" | "SexPractice" | "HomunculusType" | "BlessedTradition" | "Disease" | "Poison" | "TargetCategory", string>;
+export type ResolvedSelectOptionIdentifier = RequirableSelectOptionIdentifier | Case<"Blessing" | "Cantrip" | "Script" | "Culture" | "SexPractice" | "HomunculusType" | "BlessedTradition" | "Disease" | "Poison" | "TargetCategory" | "Advantage", string>;
 export type ResolvedSelectOption = {
     id: ResolvedSelectOptionIdentifier;
     content: Omit<GeneralSelectOption, "ap_value"> & {

package/lib/cache/activatableSelectOptions.js

@@ -733,6 +733,45 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
                 .getAllInstanceContainersOfEntity("TargetCategory")
                 .map(tc => mapToResolvedSelectOption(tc));
         }
+        case "Advantages": {
+            const mapToResolvedSelectOption = ({ id, content, }) => ({
+                id: Case("Advantage", id),
+                content: {
+                    parent: entryId,
+                    ap_value: content.ap_value,
+                    translations: mapObject(content.translations, t10n => ({
+                        name: t10n.name,
+                    })),
+                },
+                newApplications: [],
+                uses: [],
+            });
+            const { dependingOn } = selectOptionCategory.Advantages;
+            const matchesDependingOn = (prereq) => prereq.kind === "Activatable" &&
+                prereq.Activatable.active &&
+                prereq.Activatable.id.kind === "Advantage" &&
+                dependingOn.includes(prereq.Activatable.id.Advantage);
+            return database
+                .getAllInstanceContainersOfEntity("Advantage")
+                .filter(({ content }) => content.ap_value.kind === "Fixed" &&
+                (content.prerequisites?.some(p => {
+                    if (p.level !== 1) {
+                        return false;
+                    }
+                    switch (p.prerequisite.kind) {
+                        case "Disjunction":
+                            return p.prerequisite.Disjunction.list.every(matchesDependingOn);
+                        case "Group":
+                            return p.prerequisite.Group.list.some(matchesDependingOn);
+                        case "Single":
+                            return matchesDependingOn(p.prerequisite.Single);
+                        default:
+                            return assertExhaustive(p.prerequisite);
+                    }
+                }) ??
+                    false))
+                .map(mapToResolvedSelectOption);
+        }
         default:
             return assertExhaustive(selectOptionCategory);
     }

package/lib/types/Advantage.d.ts

@@ -850,6 +850,9 @@ export declare const Advantage: DB.Entity<"Advantage", {
                     volume: DB.MemberDecl<DB.Integer, false>;
                 }>, []>>>, true>;
             }>, []>>>;
+            Advantages: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdvantagesSelectOptionCategory", DB.Object<{
+                dependingOn: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>>;
         }, []>>, false>;
         rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRules", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRule", DB.Object<{
             value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleValue", {

package/lib/types/Disadvantage.d.ts

@@ -850,6 +850,9 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                     volume: DB.MemberDecl<DB.Integer, false>;
                 }>, []>>>, true>;
             }>, []>>>;
+            Advantages: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdvantagesSelectOptionCategory", DB.Object<{
+                dependingOn: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>>;
         }, []>>, false>;
         rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRules", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRule", DB.Object<{
             value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleValue", {