@optolith/database-schema 0.92.0 → 0.94.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 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.94.0](https://github.com/Optolith/database-schema/compare/v0.93.0...v0.94.0) (2026-10-12)
+
+### ⚠ BREAKING CHANGES
+
+* add distorted elven magical songs flag
+* derived trade secrets for ammunition
+
+### Features
+
+* add distorted elven magical songs flag ([837062e](https://github.com/Optolith/database-schema/commit/837062ee095a7bd706ce4c7c38517057580ee73a)), references [#199](https://github.com/Optolith/database-schema/issues/199)
+* derived trade secrets for ammunition ([6b5b5ae](https://github.com/Optolith/database-schema/commit/6b5b5ae8f59d26c594c6594e3798263fdd47095b))
+
+## [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

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.
@@ -12736,6 +12727,11 @@ export interface ComplexComplexity {
    */
   ap_value: number
 
+  /**
+   * The prerequisites of the trade secret, if any. Note that the special ability prerequisite for weapon and armor trade secrets is added automatically based on the value in the `Settings` singleton entity.
+   */
+  prerequisites?: PlainGeneralPrerequisites
+
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
    */
@@ -13002,6 +12998,11 @@ export interface Ammunition {
    */
   cost: Cost
 
+  /**
+   * The complexity of crafting the item.
+   */
+  complexity?: Complexity
+
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
    */
@@ -18633,14 +18634,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 +18885,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 {
-  /**
-   * The identifier of the special ability to grant.
-   */
-  id: ProfessionSpecialAbilityIdentifier
-
+export interface ProfessionSpecialAbilityTextOptionTranslation {
   /**
-   * The level of the received special ability. If not specified and the special ability has levels, level 1 is used automatically.
+   * The text of the option.
    */
-  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 {
@@ -19471,6 +19475,11 @@ export interface ElvenMagicalSong {
    */
   improvement_cost: ImprovementCost
 
+  /**
+   * Is the song a distorted Elven magical song?
+   */
+  is_distorted: boolean
+
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
    */
@@ -23193,6 +23202,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.
  */
@@ -27837,6 +27853,11 @@ export interface DerivedTradeSecretsSettings {
    */
   requiredSpecialAbilityForWeapons: SpecialAbilityIdentifier
 
+  /**
+   * The special ability required to buy derived trade secrets for ammunition.
+   */
+  requiredSpecialAbilityForAmmunition: SpecialAbilityIdentifier
+
   /**
    * The special ability required to buy derived trade secrets for armor.
    */

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/cache/tradeSecrets.js

@@ -2,6 +2,7 @@ import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { Case } from "tsondb/schema/gen";
 const emptyDerivedEquipmentTradeSecretsCache = {
     Armor: {},
+    Ammunition: {},
     BandageOrRemedy: {},
     Book: {},
     CeremonialItem: {},
@@ -53,15 +54,25 @@ export const buildDerivedTradeSecretsCache = (database, settings) => {
                                 id: settings.derivedTradeSecrets.requiredSpecialAbilityForWeapons,
                                 active: true,
                             })),
+                            ...(container.content.complexity.Complex.prerequisites ?? []),
                         ]
-                        : entity === "Armor"
+                        : entity === "Ammunition"
                             ? [
                                 Case("Single", Case("Activatable", {
-                                    id: settings.derivedTradeSecrets.requiredSpecialAbilityForArmor,
+                                    id: settings.derivedTradeSecrets.requiredSpecialAbilityForAmmunition,
                                     active: true,
                                 })),
+                                ...(container.content.complexity.Complex.prerequisites ?? []),
                             ]
-                            : undefined,
+                            : entity === "Armor"
+                                ? [
+                                    Case("Single", Case("Activatable", {
+                                        id: settings.derivedTradeSecrets.requiredSpecialAbilityForArmor,
+                                        active: true,
+                                    })),
+                                    ...(container.content.complexity.Complex.prerequisites ?? []),
+                                ]
+                                : (container.content.complexity.Complex.prerequisites ?? []),
                     src: container.content.complexity.Complex.src ?? container.content.src,
                     translations: Object.fromEntries(Object.entries(container.content.translations).map(([lang, translation]) => [
                         lang,

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", {