@optolith/database-schema 0.68.1 → 0.70.0

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 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.70.0](https://github.com/Optolith/database-schema/compare/v0.69.0...v0.70.0) (2026-09-27)
+
+### ⚠ BREAKING CHANGES
+
+* plant adjustments
+
+### Features
+
+* plant adjustments ([8dcd08b](https://github.com/Optolith/database-schema/commit/8dcd08b1a3492686703fbdee7f5f12c992a5d2c5)), references [#195](https://github.com/Optolith/database-schema/issues/195)
+## [0.69.0](https://github.com/Optolith/database-schema/compare/v0.68.1...v0.69.0) (2026-09-27)
+
+### ⚠ BREAKING CHANGES
+
+* ancestor blood advantage cache name typo
+
+### Features
+
+* derived trade secrets cache ([18e1ea8](https://github.com/Optolith/database-schema/commit/18e1ea889894108647f3b844c6f84f19beb8eac1))
+
+### Bug Fixes
+
+* ancestor blood advantage cache name typo ([b7d2592](https://github.com/Optolith/database-schema/commit/b7d2592cf6f8542761fa0f46b76630f57011047e))
 ## [0.68.1](https://github.com/Optolith/database-schema/compare/v0.68.0...v0.68.1) (2026-09-27)
 
 ### Features

package/gen/types.d.ts

@@ -25756,7 +25756,7 @@ export interface HerbalAid {
   /**
    * The difficulty for this aid to craft.
    */
-  crafting_difficulty: number
+  crafting_difficulty?: number
 
   /**
    * AP value and prerequisites of the herbal aid�s trade secret.
@@ -25768,6 +25768,11 @@ export interface HerbalAid {
    */
   combatUse?: HerbalAidCombatUse
 
+  /**
+   * How long this herbal aid lasts.
+   */
+  longevity?: HerbalPreservationLongevity
+
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
    */
@@ -25795,7 +25800,7 @@ export interface HerbalAidTranslation {
   /**
    * The herbal aid's description.
    */
-  description: string
+  description?: string
 
   /**
    * The ingredients used to craft this herbal aid.
@@ -25818,6 +25823,44 @@ export type HerbalAidCombatUse =
     Armor: Armor_ID
   }
 
+export interface HerbalPreservationLongevity {
+  /**
+   * An expression that evaluates to the duration.
+   */
+  value: HerbalPreservationLongevityExpression
+
+  /**
+   * The duration unit.
+   */
+  unit: DurationUnit
+
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations?: {
+    [localeId: string]: HerbalPreservationLongevityTranslation
+  }
+}
+
+export interface HerbalPreservationLongevityTranslation {
+  /**
+   * A replacement string.
+   */
+  replacement: ResponsiveTextReplace
+}
+
+export type HerbalPreservationLongevityExpression = MathOperation<HerbalPreservationLongevityValue>
+
+export type HerbalPreservationLongevityValue =
+  | {
+    kind: "Constant"
+    Constant: number
+  }
+  | {
+    kind: "Dice"
+    Dice: Dice
+  }
+
 export interface HerbalPreservation {
   /**
    * The types of this preservation.
@@ -25864,44 +25907,6 @@ export interface HerbalPreservationTranslation {
   alternative_effect: string
 }
 
-export interface HerbalPreservationLongevity {
-  /**
-   * An expression that evaluates to the duration.
-   */
-  value: HerbalPreservationLongevityExpression
-
-  /**
-   * The duration unit.
-   */
-  unit: DurationUnit
-
-  /**
-   * All translations for the entry, identified by IETF language tag (BCP47).
-   */
-  translations?: {
-    [localeId: string]: HerbalPreservationLongevityTranslation
-  }
-}
-
-export interface HerbalPreservationLongevityTranslation {
-  /**
-   * A replacement string.
-   */
-  replacement: ResponsiveTextReplace
-}
-
-export type HerbalPreservationLongevityExpression = MathOperation<HerbalPreservationLongevityValue>
-
-export type HerbalPreservationLongevityValue =
-  | {
-    kind: "Constant"
-    Constant: number
-  }
-  | {
-    kind: "Dice"
-    Dice: Dice
-  }
-
 export interface HomunculusType {
   /**
    * All translations for the entry, identified by IETF language tag (BCP47).
@@ -26355,7 +26360,7 @@ export interface PlantLongevity {
   /**
    * All translations for the entry, identified by IETF language tag (BCP47).
    */
-  translations: {
+  translations?: {
     [localeId: string]: PlantLongevityTranslation
   }
 }
@@ -26364,7 +26369,7 @@ export interface PlantLongevityTranslation {
   /**
    * The longevity of the raw plant
    */
-  raw: string
+  raw?: string
 
   /**
    * The longevity of the preserved plant

package/lib/cache/index.d.ts

@@ -4,11 +4,13 @@ import { type ActivatableSelectOptionsCache, type ResolvedSelectOption, type Res
 import { type AncestorBloodAdvantagesCache } from "./ancestorBloodAdvantages.ts";
 import { type MagicalAndBlessedAdvantagesAndDisadvantagesCache } from "./magicalAndBlessedAdvantagesAndDisadvantages.ts";
 import { type NewApplicationsAndUsesCache, type ResolvedNewSkillApplication, type ResolvedSkillUse } from "./newApplicationsAndUses.ts";
+import { type DerivedTradeSecretsCache } from "./tradeSecrets.ts";
 /**
  * Identifiers of specific entries in the database that are used for creating the cache.
  */
 export type IdMap = {
     Advantage: Record<"Blessed" | "Spellcaster", string>;
+    GeneralSpecialAbility: Record<"Weaponsmith" | "Armorer", string>;
     MagicalSpecialAbility: Record<"PropertyKnowledge", string>;
     KarmaSpecialAbility: Record<"AspectKnowledge", string>;
 };
@@ -17,7 +19,8 @@ export type IdMap = {
  */
 export type Cache = {
     activatableSelectOptions: ActivatableSelectOptionsCache;
-    sncestorBloodAdvantages: AncestorBloodAdvantagesCache;
+    ancestorBloodAdvantages: AncestorBloodAdvantagesCache;
+    derivedTradeSecrets: DerivedTradeSecretsCache;
     magicalAndBlessedAdvantagesAndDisadvantages: MagicalAndBlessedAdvantagesAndDisadvantagesCache;
     newApplicationsAndUses: NewApplicationsAndUsesCache;
 };

package/lib/cache/index.js

@@ -2,6 +2,7 @@ import { activatableSelectOptionsCacheBuilder, } from "./activatableSelectOption
 import { buildAncestorBloodAdvantagesCache, } from "./ancestorBloodAdvantages.js";
 import { buildMagicalAndBlessedAdvantagesAndDisadvantagesCache, } from "./magicalAndBlessedAdvantagesAndDisadvantages.js";
 import { buildNewApplicationsAndUsesCache, } from "./newApplicationsAndUses.js";
+import { buildDerivedTradeSecretsCache } from "./tradeSecrets.js";
 /**
  * Creates the cache by precomputing all necessary data from the database.
  * @param db The TSONDB instance containing the database.
@@ -10,12 +11,14 @@ import { buildNewApplicationsAndUsesCache, } from "./newApplicationsAndUses.js";
  */
 export const createCache = (db, idMap) => {
     const activatableSelectOptions = activatableSelectOptionsCacheBuilder(db, idMap);
-    const sncestorBloodAdvantages = buildAncestorBloodAdvantagesCache(db, idMap);
+    const ancestorBloodAdvantages = buildAncestorBloodAdvantagesCache(db, idMap);
+    const derivedTradeSecrets = buildDerivedTradeSecretsCache(db, idMap);
     const magicalAndBlessedAdvantagesAndDisadvantages = buildMagicalAndBlessedAdvantagesAndDisadvantagesCache(db, idMap);
     const newApplicationsAndUses = buildNewApplicationsAndUsesCache(db, idMap, activatableSelectOptions);
     return {
         activatableSelectOptions,
-        sncestorBloodAdvantages,
+        ancestorBloodAdvantages,
+        derivedTradeSecrets,
         magicalAndBlessedAdvantagesAndDisadvantages,
         newApplicationsAndUses,
     };

package/lib/cache/tradeSecrets.d.ts

@@ -0,0 +1,23 @@
+import { Case } from "tsondb/schema/gen";
+import type { ArmorComplexity, Complexity, EntityMap, EquipmentIdentifier, TradeSecret } from "../../gen/types.js";
+import type { CacheBuilder } from "./internal.ts";
+type EquipmentEntitiesWithComplexities = {
+    [K in EquipmentIdentifier["kind"]]: EntityMap[K] extends {
+        complexity?: Complexity | ArmorComplexity;
+    } ? K : never;
+}[EquipmentIdentifier["kind"]];
+type HerbaryEntitiesWithTradeSecrets = "Disease" | "Elixir" | "HerbalAid" | "Poison";
+export type DerivedTradeSecretsCache = {
+    equipment: {
+        [K in EquipmentEntitiesWithComplexities]: Record<string, TradeSecret>;
+    };
+    herbary: {
+        [K in HerbaryEntitiesWithTradeSecrets]: Record<string, TradeSecret>;
+    };
+    all: {
+        id: Case<"TradeSecret" | EquipmentEntitiesWithComplexities | HerbaryEntitiesWithTradeSecrets, string>;
+        content: TradeSecret;
+    }[];
+};
+export declare const buildDerivedTradeSecretsCache: CacheBuilder<DerivedTradeSecretsCache>;
+export {};

package/lib/cache/tradeSecrets.js

@@ -0,0 +1,126 @@
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { Case } from "tsondb/schema/gen";
+const emptyDerivedEquipmentTradeSecretsCache = {
+    Armor: {},
+    BandageOrRemedy: {},
+    Book: {},
+    CeremonialItem: {},
+    Clothes: {},
+    Container: {},
+    IlluminationLightSource: {},
+    IlluminationRefillOrSupply: {},
+    Jewelry: {},
+    Laboratory: {},
+    Liebesspielzeug: {},
+    LuxuryGood: {},
+    MagicalArtifact: {},
+    MusicalInstrument: {},
+    OrienteeringAid: {},
+    RopeOrChain: {},
+    Stationery: {},
+    ThievesTool: {},
+    ToolOfTheTrade: {},
+    TravelGearOrTool: {},
+    Vehicle: {},
+    Weapon: {},
+    WeaponAccessory: {},
+};
+const emptyDerivedHerbaryTradeSecretsCache = {
+    Disease: {},
+    Elixir: {},
+    HerbalAid: {},
+    Poison: {},
+};
+export const buildDerivedTradeSecretsCache = (database, idMap) => {
+    const cache = {
+        equipment: emptyDerivedEquipmentTradeSecretsCache,
+        herbary: emptyDerivedHerbaryTradeSecretsCache,
+        all: database.getAllInstanceContainersOfEntity("TradeSecret").map(container => ({
+            id: Case("TradeSecret", container.id),
+            content: container.content,
+        })),
+    };
+    for (const entity of Object.keys(cache.equipment)) {
+        for (const container of database.getAllInstanceContainersOfEntity(entity)) {
+            if (container.content.complexity && container.content.complexity.kind === "Complex") {
+                const derivedTradeSecret = {
+                    ap_value: Case("Fixed", container.content.complexity.Complex.ap_value),
+                    is_secret_knowledge: false,
+                    prerequisites: entity === "Weapon"
+                        ? [
+                            Case("Single", Case("Activatable", {
+                                id: Case("GeneralSpecialAbility", idMap.GeneralSpecialAbility.Weaponsmith),
+                                active: true,
+                            })),
+                        ]
+                        : entity === "Armor"
+                            ? [
+                                Case("Single", Case("Activatable", {
+                                    id: Case("GeneralSpecialAbility", idMap.GeneralSpecialAbility.Armorer),
+                                    active: true,
+                                })),
+                            ]
+                            : undefined,
+                    src: container.content.complexity.Complex.src ?? container.content.src,
+                    translations: Object.fromEntries(Object.entries(container.content.translations).map(([lang, translation]) => [
+                        lang,
+                        {
+                            name: translation.name,
+                        },
+                    ])),
+                };
+                cache.equipment[entity][container.id] = derivedTradeSecret;
+                cache.all.push({
+                    id: Case(entity, container.id),
+                    content: derivedTradeSecret,
+                });
+            }
+        }
+    }
+    const addTradeSecretToHerbaryCache = (entity, container, tradeSecret) => {
+        const derivedTradeSecret = {
+            ap_value: Case("Fixed", tradeSecret.ap_value),
+            is_secret_knowledge: false,
+            prerequisites: tradeSecret.prerequisites,
+            src: tradeSecret.src ?? container.content.src,
+            translations: Object.fromEntries(Object.entries(container.content.translations).map(([lang, translation]) => [
+                lang,
+                {
+                    name: translation.name,
+                },
+            ])),
+        };
+        cache.herbary[entity][container.id] = derivedTradeSecret;
+        cache.all.push({
+            id: Case(entity, container.id),
+            content: derivedTradeSecret,
+        });
+    };
+    for (const entity of Object.keys(emptyDerivedHerbaryTradeSecretsCache)) {
+        switch (entity) {
+            case "Disease":
+            case "Elixir":
+            case "HerbalAid":
+                for (const container of database.getAllInstanceContainersOfEntity(entity)) {
+                    if (container.content.trade_secret) {
+                        addTradeSecretToHerbaryCache(entity, container, container.content.trade_secret);
+                    }
+                }
+                break;
+            case "Poison":
+                for (const container of database.getAllInstanceContainersOfEntity(entity)) {
+                    if (container.content.source_type.kind === "AlchemicalPoison") {
+                        addTradeSecretToHerbaryCache(entity, container, container.content.source_type.AlchemicalPoison.trade_secret);
+                    }
+                    else if (container.content.source_type.kind == "AnimalVenom" &&
+                        container.content.source_type.AnimalVenom.complexity?.kind === "Complex") {
+                        addTradeSecretToHerbaryCache(entity, container, container.content.source_type.AnimalVenom.complexity.Complex);
+                    }
+                }
+                break;
+            default:
+                return assertExhaustive(entity);
+        }
+    }
+    return cache;
+};

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

@@ -9,7 +9,7 @@ export declare const HerbalAid: DB.Entity<"HerbalAid", {
         Defensive: DB.EnumCase<null>;
         Supernatural: DB.EnumCase<null>;
     }, []>>>, true>;
-    crafting_difficulty: DB.MemberDecl<DB.Integer, true>;
+    crafting_difficulty: DB.MemberDecl<DB.Integer, false>;
     trade_secret: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RecipeTradeSecret", 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", {
@@ -82,6 +82,38 @@ export declare const HerbalAid: DB.Entity<"HerbalAid", {
         Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
         Armor: DB.EnumCase<DB.ReferenceIdentifier>;
     }, []>>, false>;
+    longevity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HerbalPreservationLongevity", DB.Object<{
+        value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HerbalPreservationLongevityExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../../_MathExpression.ts").MathOperation>, []>>, true>;
+        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+            Seconds: DB.EnumCase<null>;
+            Minutes: DB.EnumCase<null>;
+            Hours: DB.EnumCase<null>;
+            Days: DB.EnumCase<null>;
+            Weeks: DB.EnumCase<null>;
+            Months: DB.EnumCase<null>;
+            Years: DB.EnumCase<null>;
+            Decades: DB.EnumCase<null>;
+            Centuries: DB.EnumCase<null>;
+            Actions: DB.EnumCase<null>;
+            CombatRounds: DB.EnumCase<null>;
+            Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomDurationUnit", DB.Object<{
+                translations: DB.MemberDecl<DB.NestedEntityMap<"CustomDurationUnitTranslation", {
+                    name: DB.MemberDecl<DB.String, true>;
+                    fullNumber: DB.MemberDecl<DB.String, true>;
+                    full: DB.MemberDecl<DB.String, true>;
+                    symbol: DB.MemberDecl<DB.String, true>;
+                    compressedNumber: DB.MemberDecl<DB.String, true>;
+                    compressed: DB.MemberDecl<DB.String, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"HerbalPreservationLongevityTranslation", {
+            replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                full: DB.MemberDecl<DB.String, true>;
+                compressed: DB.MemberDecl<DB.String, true>;
+            }>, []>>, 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, {
@@ -125,7 +157,7 @@ export declare const HerbalAid: DB.Entity<"HerbalAid", {
     }>, []>>>, []>>, true>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"HerbalAidTranslation", {
         name: DB.MemberDecl<DB.String, true>;
-        description: DB.MemberDecl<DB.String, true>;
+        description: DB.MemberDecl<DB.String, false>;
         ingredients: DB.MemberDecl<DB.Array<DB.String>, true>;
         typical_tools: DB.MemberDecl<DB.Array<DB.String>, false>;
     }>, true>;

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

@@ -3,6 +3,7 @@ import { src } from "../../source/_PublicationRef.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { WeaponIdentifier, ArmorIdentifier } from "../../_Identifier.js";
 import { EffectType, RecipeTradeSecret } from "./_Herbary.js";
+import { HerbalPreservationLongevity } from "./HerbalPreservation.js";
 export const HerbalAid = DB.Entity(import.meta.url, {
     name: "HerbalAid",
     namePlural: "HerbalAids",
@@ -11,7 +12,7 @@ export const HerbalAid = DB.Entity(import.meta.url, {
             comment: "The plant types this aid belongs to.",
             type: DB.Array(DB.IncludeIdentifier(EffectType), { minItems: 1, uniqueItems: true }),
         }),
-        crafting_difficulty: DB.Required({
+        crafting_difficulty: DB.Optional({
             comment: "The difficulty for this aid to craft.",
             type: DB.Integer(),
         }),
@@ -23,13 +24,17 @@ export const HerbalAid = DB.Entity(import.meta.url, {
             comment: "The armor or weapon this herbal aid represents.",
             type: DB.IncludeIdentifier(HerbalAidCombatUse),
         }),
+        longevity: DB.Optional({
+            comment: "How long this herbal aid lasts.",
+            type: DB.IncludeIdentifier(HerbalPreservationLongevity),
+        }),
         src,
         translations: NestedTranslationMap(DB.Required, "HerbalAid", DB.Object({
             name: DB.Required({
                 comment: "The herbal aid's name.",
                 type: DB.String({ minLength: 1 }),
             }),
-            description: DB.Required({
+            description: DB.Optional({
                 comment: "The herbal aid's description.",
                 type: DB.String({ minLength: 1, markdown: "block" }),
             }),

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

@@ -157,9 +157,9 @@ export declare const Plant: DB.Entity<"Plant", {
     longevity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlantLongevity", DB.Object<{
         preservations: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
         translations: DB.MemberDecl<DB.NestedEntityMap<"PlantLongevityTranslation", {
-            raw: DB.MemberDecl<DB.String, true>;
+            raw: DB.MemberDecl<DB.String, false>;
             preserved: DB.MemberDecl<DB.String, 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>;

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

@@ -270,8 +270,8 @@ const PlantLongevity = DB.TypeAlias(import.meta.url, {
             comment: "The preservations with alternative effect of this preserved plant",
             type: DB.Array(HerbalPreservationIdentifier(), { minItems: 1, uniqueItems: true }),
         }),
-        translations: NestedTranslationMap(DB.Required, "PlantLongevity", DB.Object({
-            raw: DB.Required({
+        translations: NestedTranslationMap(DB.Optional, "PlantLongevity", DB.Object({
+            raw: DB.Optional({
                 comment: "The longevity of the raw plant",
                 type: DB.String({ minLength: 1, markdown: "block" }),
             }),
@@ -279,6 +279,6 @@ const PlantLongevity = DB.TypeAlias(import.meta.url, {
                 comment: "The longevity of the preserved plant",
                 type: DB.String({ minLength: 1, markdown: "block" }),
             }),
-        })),
-    }),
+        }, { minProperties: 1 })),
+    }, { minProperties: 1 }),
 });

package/package.json

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