@optolith/database-schema 0.48.0 → 0.50.0

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 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.50.0](https://github.com/Optolith/database-schema/compare/v0.49.0...v0.50.0) (2026-06-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* allow arbitrary AP values for enhancements
+
+### Features
+
+* allow arbitrary AP values for enhancements ([1d06407](https://github.com/Optolith/database-schema/commit/1d06407eb4dee8fec24bc9f8d0d6e31833e4f995))
+* allow arbitrary text input for enhancements ([3a3af6e](https://github.com/Optolith/database-schema/commit/3a3af6e574c1a7d05113ebc75d5d6fa1b92c8dce))
+
+## [0.49.0](https://github.com/Optolith/database-schema/compare/v0.48.0...v0.49.0) (2026-06-13)
+
+
+### ⚠ BREAKING CHANGES
+
+* add missing skill rating case to parameter expression
+
+### Bug Fixes
+
+* add missing skill rating case to parameter expression ([64ee1cc](https://github.com/Optolith/database-schema/commit/64ee1cce6adccc2027bb890289b31e2cea653645))
+
 ## [0.48.0](https://github.com/Optolith/database-schema/compare/v0.47.4...v0.48.0) (2026-06-13)
 
 

package/gen/types.d.ts

@@ -298,6 +298,7 @@ export type EnumMap = {
   ElixirEffect: ElixirEffect
   EnchantmentCost: EnchantmentCost
   EncumbranceInfluence: EncumbranceInfluence
+  EnhancementAdventurePoints: EnhancementAdventurePoints
   EnhancementPrerequisiteGroup: EnhancementPrerequisiteGroup
   EquipmentIdentifier: EquipmentIdentifier
   ExpressionBasedParameterExpressionValue: ExpressionBasedParameterExpressionValue
@@ -571,6 +572,7 @@ export type TypeAliasMap = {
   DerivedCharacteristicPermanentLoss: DerivedCharacteristicPermanentLoss
   DerivedCharacteristicPrerequisites: DerivedCharacteristicPrerequisites
   DerivedCharacteristicPurchase: DerivedCharacteristicPurchase
+  DerivedEnhancementAdventurePoints: DerivedEnhancementAdventurePoints
   Dice: Dice
   DiceBasedIntoxicantAddictionInterval: DiceBasedIntoxicantAddictionInterval
   DieType: DieType
@@ -6916,6 +6918,9 @@ export type ExpressionBasedParameterExpressionValue =
   | {
     kind: "SkillPoints"
   }
+  | {
+    kind: "SkillRating"
+  }
 
 export type RangeUnit =
   | {
@@ -7952,9 +7957,9 @@ export interface Enhancement {
   skill_rating: number
 
   /**
-   * The value to multiply with the numeric representation of the associated skill's improvement cost to form the final AP cost of this enhancement.
+   * Defines how to determine the AP cost of an enhancement.
    */
-  adventure_points_modifier: number
+  adventurePoints: EnhancementAdventurePoints
 
   prerequisites?: EnhancementPrerequisites
 
@@ -7987,6 +7992,11 @@ export interface EnhancementTranslation {
    */
   effect: string
 
+  /**
+   * A string that is used as a label for an input field.
+   */
+  input?: string
+
   errata?: Errata
 }
 
@@ -19927,6 +19937,26 @@ export interface InfluenceEffect {
   text: string
 }
 
+/**
+ * Defines how to determine the AP cost of an enhancement.
+ */
+export type EnhancementAdventurePoints =
+  | {
+    kind: "DerivedFromImprovementCost"
+    DerivedFromImprovementCost: DerivedEnhancementAdventurePoints
+  }
+  | {
+    kind: "Constant"
+    Constant: number
+  }
+
+export interface DerivedEnhancementAdventurePoints {
+  /**
+   * The value to multiply with the numeric representation of the associated skill's improvement cost to form the final AP cost of this enhancement.
+   */
+  multiplier: number
+}
+
 export type EnhancementPrerequisites = PlainPrerequisites<EnhancementPrerequisiteGroup>
 
 export type EnhancementPrerequisiteGroup =

package/lib/types/Ceremony.d.ts

@@ -549,7 +549,12 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
             Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
         skill_rating: DB.MemberDecl<DB.Integer, true>;
-        adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+        adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+            DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+                multiplier: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Constant: DB.EnumCase<DB.Integer>;
+        }, []>>, true>;
         prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
             Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
             Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -618,6 +623,7 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
         translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
             name: DB.MemberDecl<DB.String, true>;
             effect: DB.MemberDecl<DB.String, true>;
+            input: DB.MemberDecl<DB.String, false>;
             errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
                 date: DB.MemberDecl<DB.Date, true>;
                 description: DB.MemberDecl<DB.String, true>;

package/lib/types/LiturgicalChant.d.ts

@@ -549,7 +549,12 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
             Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
         skill_rating: DB.MemberDecl<DB.Integer, true>;
-        adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+        adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+            DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+                multiplier: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Constant: DB.EnumCase<DB.Integer>;
+        }, []>>, true>;
         prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
             Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
             Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -618,6 +623,7 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
         translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
             name: DB.MemberDecl<DB.String, true>;
             effect: DB.MemberDecl<DB.String, true>;
+            input: DB.MemberDecl<DB.String, false>;
             errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
                 date: DB.MemberDecl<DB.Date, true>;
                 description: DB.MemberDecl<DB.String, true>;

package/lib/types/Ritual.d.ts

@@ -552,7 +552,12 @@ export declare const Ritual: DB.Entity<"Ritual", {
             Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
         skill_rating: DB.MemberDecl<DB.Integer, true>;
-        adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+        adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+            DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+                multiplier: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Constant: DB.EnumCase<DB.Integer>;
+        }, []>>, true>;
         prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
             Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
             Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -621,6 +626,7 @@ export declare const Ritual: DB.Entity<"Ritual", {
         translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
             name: DB.MemberDecl<DB.String, true>;
             effect: DB.MemberDecl<DB.String, true>;
+            input: DB.MemberDecl<DB.String, false>;
             errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
                 date: DB.MemberDecl<DB.Date, true>;
                 description: DB.MemberDecl<DB.String, true>;

package/lib/types/Spell.d.ts

@@ -552,7 +552,12 @@ export declare const Spell: DB.Entity<"Spell", {
             Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
         skill_rating: DB.MemberDecl<DB.Integer, true>;
-        adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+        adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+            DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+                multiplier: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Constant: DB.EnumCase<DB.Integer>;
+        }, []>>, true>;
         prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
             Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
             Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -621,6 +626,7 @@ export declare const Spell: DB.Entity<"Spell", {
         translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
             name: DB.MemberDecl<DB.String, true>;
             effect: DB.MemberDecl<DB.String, true>;
+            input: DB.MemberDecl<DB.String, false>;
             errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
                 date: DB.MemberDecl<DB.Date, true>;
                 description: DB.MemberDecl<DB.String, true>;

package/lib/types/_ActivatableSkill.js

@@ -100,5 +100,6 @@ const ExpressionBasedParameterExpressionValue = DB.Enum(import.meta.url, {
         Constant: DB.EnumCase({ type: DB.Integer({ minimum: 1 }) }),
         QualityLevels: DB.EnumCase({ type: null }),
         SkillPoints: DB.EnumCase({ type: null }),
+        SkillRating: DB.EnumCase({ type: null }),
     }),
 });

package/lib/types/_ActivatableSkillCheckResultBased.d.ts

@@ -1,9 +1,4 @@
 import * as DB from "tsondb/schema/dsl";
-export declare const CheckResultValue: DB.Enum<"CheckResultValue", {
-    QualityLevels: DB.EnumCase<null>;
-    SkillPoints: DB.EnumCase<null>;
-    SkillRating: DB.EnumCase<null>;
-}, []>;
 export declare const CheckResultBasedModifier: DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
     arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
         Multiply: DB.EnumCase<null>;
@@ -11,17 +6,3 @@ export declare const CheckResultBasedModifier: DB.TypeAlias<"CheckResultBasedMod
     }, []>>, true>;
     value: DB.MemberDecl<DB.Integer, true>;
 }>, []>;
-export declare const CheckResultBased: DB.TypeAlias<"CheckResultBased", DB.Object<{
-    base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
-        QualityLevels: DB.EnumCase<null>;
-        SkillPoints: DB.EnumCase<null>;
-        SkillRating: DB.EnumCase<null>;
-    }, []>>, true>;
-    modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
-        arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
-            Multiply: DB.EnumCase<null>;
-            Divide: DB.EnumCase<null>;
-        }, []>>, true>;
-        value: DB.MemberDecl<DB.Integer, true>;
-    }>, []>>, false>;
-}>, []>;

package/lib/types/_ActivatableSkillCheckResultBased.js

@@ -1,13 +1,4 @@
 import * as DB from "tsondb/schema/dsl";
-export const CheckResultValue = DB.Enum(import.meta.url, {
-    name: "CheckResultValue",
-    comment: "Defines the derived (unitless) value.",
-    values: () => ({
-        QualityLevels: DB.EnumCase({ type: null }),
-        SkillPoints: DB.EnumCase({ type: null }),
-        SkillRating: DB.EnumCase({ type: null }),
-    }),
-});
 const CheckResultArithmetic = DB.Enum(import.meta.url, {
     name: "CheckResultArithmetic",
     comment: "Defines how the the `value` is set off against the check result.",
@@ -29,17 +20,3 @@ export const CheckResultBasedModifier = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
-export const CheckResultBased = DB.TypeAlias(import.meta.url, {
-    name: "CheckResultBased",
-    comment: "Defines a parameter being based on a check result.",
-    type: () => DB.Object({
-        base: DB.Required({
-            comment: "The base value that is derived from the check result.",
-            type: DB.IncludeIdentifier(CheckResultValue),
-        }),
-        modifier: DB.Optional({
-            comment: "If defined, it modifies the base value.",
-            type: DB.IncludeIdentifier(CheckResultBasedModifier),
-        }),
-    }),
-});

package/lib/types/_Enhancements.d.ts

@@ -10,7 +10,12 @@ export declare const Enhancements: DB.TypeAlias<"Enhancements", DB.ChildEntities
         Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
     }, []>>, true>;
     skill_rating: DB.MemberDecl<DB.Integer, true>;
-    adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+    adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+        DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+            multiplier: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+        Constant: DB.EnumCase<DB.Integer>;
+    }, []>>, true>;
     prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
         Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
         Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -79,6 +84,7 @@ export declare const Enhancements: DB.TypeAlias<"Enhancements", DB.ChildEntities
     translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
         name: DB.MemberDecl<DB.String, true>;
         effect: DB.MemberDecl<DB.String, true>;
+        input: DB.MemberDecl<DB.String, false>;
         errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
             date: DB.MemberDecl<DB.Date, true>;
             description: DB.MemberDecl<DB.String, true>;
@@ -93,7 +99,12 @@ export declare const Enhancement: DB.Entity<"Enhancement", {
         Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
     }, []>>, true>;
     skill_rating: DB.MemberDecl<DB.Integer, true>;
-    adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+    adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+        DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+            multiplier: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+        Constant: DB.EnumCase<DB.Integer>;
+    }, []>>, true>;
     prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
         Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
         Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -162,6 +173,7 @@ export declare const Enhancement: DB.Entity<"Enhancement", {
     translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
         name: DB.MemberDecl<DB.String, true>;
         effect: DB.MemberDecl<DB.String, true>;
+        input: DB.MemberDecl<DB.String, false>;
         errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
             date: DB.MemberDecl<DB.Date, true>;
             description: DB.MemberDecl<DB.String, true>;

package/lib/types/_Enhancements.js

@@ -2,6 +2,7 @@
  * @title Enhancements
  */
 import * as DB from "tsondb/schema/dsl";
+import { input } from "./_Activatable.js";
 import { SkillWithEnhancementsIdentifier } from "./_IdentifierGroup.js";
 import { EnhancementPrerequisites } from "./_Prerequisite.js";
 import { NestedTranslationMap } from "./Locale.js";
@@ -28,11 +29,9 @@ export const Enhancement = DB.Entity(import.meta.url, {
                 multipleOf: 2,
             }),
         }),
-        adventure_points_modifier: DB.Required({
-            comment: "The value to multiply with the numeric representation of the associated skill's improvement cost to form the final AP cost of this enhancement.",
-            type: DB.Integer({
-                minimum: 1,
-            }),
+        adventurePoints: DB.Required({
+            comment: "Defines how to determine the AP cost of an enhancement.",
+            type: DB.IncludeIdentifier(EnhancementAdventurePoints),
         }),
         prerequisites: DB.Optional({
             type: DB.IncludeIdentifier(EnhancementPrerequisites),
@@ -55,6 +54,7 @@ export const Enhancement = DB.Entity(import.meta.url, {
                     markdown: "block",
                 }),
             }),
+            input,
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),
             }),
@@ -78,3 +78,31 @@ export const Enhancement = DB.Entity(import.meta.url, {
         ],
     ],
 });
+const EnhancementAdventurePoints = DB.Enum(import.meta.url, {
+    name: "EnhancementAdventurePoints",
+    comment: "Defines how to determine the AP cost of an enhancement.",
+    values: () => ({
+        DerivedFromImprovementCost: DB.EnumCase({
+            comment: "Use the numeric representation of the associated skill's improvement cost as the AP cost of this enhancement.",
+            type: DB.IncludeIdentifier(DerivedEnhancementAdventurePoints),
+        }),
+        Constant: DB.EnumCase({
+            comment: "Use the specified constant value as the AP cost of this enhancement.",
+            type: DB.Integer({
+                minimum: 1,
+            }),
+        }),
+    }),
+});
+const DerivedEnhancementAdventurePoints = DB.TypeAlias(import.meta.url, {
+    name: "DerivedEnhancementAdventurePoints",
+    type: () => DB.Object({
+        multiplier: DB.Required({
+            comment: "The value to multiply with the numeric representation of the associated skill's improvement cost to form the final AP cost of this enhancement.",
+            type: DB.Integer({
+                minimum: 1,
+                maximum: 3,
+            }),
+        }),
+    }),
+});

package/package.json

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