@optolith/database-schema 0.102.1 → 0.103.1

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 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.103.1](https://github.com/Optolith/database-schema/compare/v0.103.0...v0.103.1) (2026-10-15)
+
+### Features
+
+* add optional complexity to animal care ([cff0eea](https://github.com/Optolith/database-schema/commit/cff0eea7bdfd60b8a8409776c076f456e4794bbe))
+
+## [0.103.0](https://github.com/Optolith/database-schema/compare/v0.102.1...v0.103.0) (2026-10-15)
+
+### ⚠ BREAKING CHANGES
+
+* close combat technique can validate presence of attack modifier
+
+### Features
+
+* close combat technique can validate presence of attack modifier ([e9cef1b](https://github.com/Optolith/database-schema/commit/e9cef1b22987ef4137588e666125c914f402a4f1))
+* prepare future migration stages ([7719ecc](https://github.com/Optolith/database-schema/commit/7719eccbcb188c7bb2f9fcb377c598605d8855cc))
+
 ## [0.102.1](https://github.com/Optolith/database-schema/compare/v0.102.0...v0.102.1) (2026-10-15)
 
 ## [0.102.0](https://github.com/Optolith/database-schema/compare/v0.101.0...v0.102.0) (2026-10-15)

package/gen/types.d.ts

@@ -5371,6 +5371,11 @@ export interface CloseCombatTechniqueTranslation {
  * Special rules for the combat technique that apply to all weapons in this category.
  */
 export interface CloseCombatTechniqueSpecialRules {
+  /**
+   * Do weapons of this combat technique have an attack modifier?
+   */
+  hasAttackModifier: WeaponCombatTechniqueValueRule
+
   /**
    * Is parrying possible with this combat technique?
    */
@@ -23731,6 +23736,11 @@ export interface AnimalCare {
    */
   type: AnimalCareType
 
+  /**
+   * 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.
    */

package/lib/cache/tradeSecrets.js

@@ -1,6 +1,7 @@
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { Case } from "tsondb/schema/gen";
 const emptyDerivedEquipmentTradeSecretsCache = {
+    AnimalCare: {},
     Armor: {},
     ArmorAccessory: {},
     Ammunition: {},

package/lib/main.d.ts

@@ -1,3 +1,4 @@
+import type { MigrationStage } from "tsondb";
 import { Schema } from "tsondb/schema";
 import type { ChildEntityMap, EntityMap, EnumMap, SingletonEntityMap, TypeAliasMap } from "../gen/types.js";
 declare module "tsondb/schema/gen" {
@@ -17,3 +18,4 @@ export interface TSONDBTypes {
     typeAliasMap: TypeAliasMap;
 }
 export declare const schema: Schema<TSONDBTypes>;
+export declare const migrationStages: MigrationStage<TSONDBTypes>[];

package/lib/main.js

@@ -179,64 +179,4 @@ export const schema = new Schema((await import("../package.json", { with: { type
     Types.WorkingSupernaturalCreature,
     Types.ZibiljaRitual,
 ], Types.Locale);
-// /**
-//  * A dictionary of cache types and their associated location.
-//  */
-// export type CachePaths = {
-//   [K in keyof CacheMap]: string
-// }
-// export type CacheOptions = {
-//   /**
-//    * Whether to pretty-print the JSON. Default is `false`.
-//    */
-//   pretty?: boolean
-// }
-// /**
-//  * Builds the cache and writes it to the specified paths in JSON format.
-//  * @param cachePaths The absolute paths to write each cache to.
-//  * @param validResults The data to build the cache from. Usually the result of
-//  * `getAllValidData`.
-//  * @param options Configuration options for building the cache.
-//  */
-// export const buildCache = async (
-//   cachePaths: CachePaths,
-//   validResults: ValidResults,
-//   options: CacheOptions = {}
-// ): Promise<void> => {
-//   const { pretty = false } = options
-//   const activatableSelectOptionsCache = cacheMap.activatableSelectOptions.builder(validResults)
-//   const ancestorBloodAdvantagesCache = cacheMap.ancestorBloodAdvantages.builder(validResults)
-//   const magicalAndBlessedAdvantagesAndDisadvantagesCache =
-//     cacheMap.magicalAndBlessedAdvantagesAndDisadvantages.builder(validResults)
-//   const newApplicationsAndUsesCache = cacheMap.newApplicationsAndUses.builder(
-//     validResults,
-//     activatableSelectOptionsCache
-//   )
-//   const cacheData: CacheMap = {
-//     activatableSelectOptions: activatableSelectOptionsCache,
-//     ancestorBloodAdvantages: ancestorBloodAdvantagesCache,
-//     magicalAndBlessedAdvantagesAndDisadvantages: magicalAndBlessedAdvantagesAndDisadvantagesCache,
-//     newApplicationsAndUses: newApplicationsAndUsesCache,
-//   }
-//   for (const [cacheName, cachePath] of Object.entries(cachePaths)) {
-//     await mkdir(dirname(cachePath), { recursive: true })
-//     await writeFile(
-//       cachePath,
-//       JSON.stringify(cacheData[cacheName as keyof CachePaths], null, pretty ? 2 : undefined),
-//       "utf-8"
-//     )
-//   }
-// }
-// /**
-//  * Reads the cache from the specified paths in JSON format.
-//  * @param cachePaths The absolute paths to read each cache from.
-//  * @returns
-//  */
-// export const getCache = async (cachePaths: CachePaths): Promise<CacheMap> => {
-//   const cache: Partial<CacheMap> = {}
-//   for (const [cacheName, cachePath] of Object.entries(cachePaths)) {
-//     const cacheData = JSON.parse(await readFile(cachePath, "utf-8"))
-//     cache[cacheName as keyof CacheMap] = cacheData
-//   }
-//   return cache as CacheMap
-// }
+export const migrationStages = [];

package/lib/types/CombatTechnique.d.ts

@@ -1,6 +1,11 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const CloseCombatTechnique: DB.Entity<"CloseCombatTechnique", {
     special: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CloseCombatTechniqueSpecialRules", DB.Object<{
+        hasAttackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"WeaponCombatTechniqueValueRule", {
+            Required: DB.EnumCase<null>;
+            Optional: DB.EnumCase<null>;
+            Prohibited: DB.EnumCase<null>;
+        }, []>>, true>;
         can_parry: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"WeaponCombatTechniqueValueRule", {
             Required: DB.EnumCase<null>;
             Optional: DB.EnumCase<null>;

package/lib/types/CombatTechnique.js

@@ -69,6 +69,10 @@ const CloseCombatTechniqueSpecialRules = DB.TypeAlias(import.meta.url, {
     name: "CloseCombatTechniqueSpecialRules",
     comment: "Special rules for the combat technique that apply to all weapons in this category.",
     type: () => DB.Object({
+        hasAttackModifier: DB.Required({
+            comment: "Do weapons of this combat technique have an attack modifier?",
+            type: DB.IncludeIdentifier(WeaponCombatTechniqueValueRule),
+        }),
         can_parry: DB.Required({
             comment: "Is parrying possible with this combat technique?",
             type: DB.IncludeIdentifier(WeaponCombatTechniqueValueRule),

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

@@ -37,6 +37,78 @@ export declare const AnimalCare: DB.Entity<"AnimalCare", {
             }, []>>, true>;
         }>, []>>>;
     }, []>>, true>;
+    complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Complexity", {
+        Primitive: DB.EnumCase<null>;
+        Simple: DB.EnumCase<null>;
+        Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
+            ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
+            src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+                id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+                    initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                        printing: DB.MemberDecl<DB.Integer, false>;
+                        pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                            first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                InsideCoverFront: DB.EnumCase<null>;
+                                InsideCoverBack: DB.EnumCase<null>;
+                                Numbered: DB.EnumCase<DB.Integer>;
+                            }, []>>, true>;
+                            last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                InsideCoverFront: DB.EnumCase<null>;
+                                InsideCoverBack: DB.EnumCase<null>;
+                                Numbered: DB.EnumCase<DB.Integer>;
+                            }, []>>, false>;
+                        }>, []>>>, true>;
+                        isRemoved: DB.MemberDecl<DB.Boolean, false>;
+                    }>, []>>, true>;
+                    revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                        Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                            printing: DB.MemberDecl<DB.Integer, true>;
+                            pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                                first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                    InsideCoverFront: DB.EnumCase<null>;
+                                    InsideCoverBack: DB.EnumCase<null>;
+                                    Numbered: DB.EnumCase<DB.Integer>;
+                                }, []>>, true>;
+                                last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                    InsideCoverFront: DB.EnumCase<null>;
+                                    InsideCoverBack: DB.EnumCase<null>;
+                                    Numbered: DB.EnumCase<DB.Integer>;
+                                }, []>>, false>;
+                            }>, []>>>, true>;
+                        }>, []>>>;
+                        Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                            printing: DB.MemberDecl<DB.Integer, true>;
+                        }>, []>>>;
+                    }, []>>>, false>;
+                }>, true>;
+            }>, []>>>, []>>, false>;
+        }>, []>>>;
+    }, []>>, false>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {

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

@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 import { src } from "../../source/_PublicationRef.js";
-import { Cost, DefaultItemTranslations, FixedCost, Weight } from "./_Item.js";
+import { Complexity, Cost, DefaultItemTranslations, FixedCost, Weight } from "./_Item.js";
 export const AnimalCare = DB.Entity(import.meta.url, {
     name: "AnimalCare",
     namePlural: "AnimalCare",
@@ -9,6 +9,10 @@ export const AnimalCare = DB.Entity(import.meta.url, {
             comment: "Values depending on whether the animal care is feed.",
             type: DB.IncludeIdentifier(AnimalCareType),
         }),
+        complexity: DB.Optional({
+            comment: "The complexity of crafting the item.",
+            type: DB.IncludeIdentifier(Complexity),
+        }),
         src,
         translations: DefaultItemTranslations("AnimalCare"),
     }),

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

@@ -62,6 +62,7 @@ export const checkWeaponCombatTechniqueIntegrity = ({ instanceContent, getInstan
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- integrity has been checked, it must be present
             const ct = getInstanceById("CloseCombatTechnique", ctId);
             return [
+                checkPart(ct.special.hasAttackModifier, meleeUse.attackModifier, "an attack modifier", "close", ctId),
                 checkPart(ct.special.can_parry, meleeUse.parryModifier, "a parry modifier", "close", ctId),
                 checkPart(ct.special.has_damage_threshold, meleeUse.damage_threshold, "a damage threshold", "close", ctId),
                 checkPart(ct.special.has_length, meleeUse.length, "a length", "close", ctId),

package/package.json

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