@optolith/database-schema 0.112.0 → 0.113.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.113.1](https://github.com/Optolith/database-schema/compare/v0.113.0...v0.113.1) (2026-10-26)
+
+### Bug Fixes
+
+* **cache:** missing sources for derived select options ([68347f2](https://github.com/Optolith/database-schema/commit/68347f21f6adfc62b4c755b4bc1ad5b8db0a543e))
+
+## [0.113.0](https://github.com/Optolith/database-schema/compare/v0.112.0...v0.113.0) (2026-10-26)
+
+### ⚠ BREAKING CHANGES
+
+* pin enhancement focus rules in settings
+
+### Features
+
+* **cache:** include parent source refs in new applications and uses ([26a0c1a](https://github.com/Optolith/database-schema/commit/26a0c1a959dd7c5ced909cee03a13be67174cc5b))
+* pin enhancement focus rules in settings ([711a7d5](https://github.com/Optolith/database-schema/commit/711a7d5ac1f008e0d684cb4a8e94c7c9209eae8a))
+
 ## [0.112.0](https://github.com/Optolith/database-schema/compare/v0.111.1...v0.112.0) (2026-10-24)
 
 ### ⚠ BREAKING CHANGES

package/gen/types.d.ts

@@ -686,6 +686,7 @@ export type TypeAliasMap = {
   EnergyType: EnergyType
   EnhancementPrerequisite: EnhancementPrerequisite
   EnhancementPrerequisites: EnhancementPrerequisites
+  EnhancementsSettings: EnhancementsSettings
   EquipmentPackageItem: EquipmentPackageItem
   EquipmentPrerequisites: EquipmentPrerequisites
   Errata: Errata
@@ -29260,6 +29261,11 @@ export interface Settings {
    */
   styles: StyleSpecialAbilitySettings
 
+  /**
+   * Spell and Liturgical Chant Enhancements are part of focus rules. This type defines which focus rule must be enabled in order to use an enhancement. Essentially, this is a default prerequisite they must meet, but manually inserting them with every enhancement is a lot of work and error-prone. Therefore, in order to use an enhancement, prerequisites for the respective focus rule must be generated for every entry.
+   */
+  enhancements: EnhancementsSettings
+
   /**
    * The publication that extends the description of books with additional information.
    */
@@ -29341,6 +29347,21 @@ export interface StyleSpecialAbilitySettings {
   liturgical: FocusRule_ID
 }
 
+/**
+ * Spell and Liturgical Chant Enhancements are part of focus rules. This type defines which focus rule must be enabled in order to use an enhancement. Essentially, this is a default prerequisite they must meet, but manually inserting them with every enhancement is a lot of work and error-prone. Therefore, in order to use an enhancement, prerequisites for the respective focus rule must be generated for every entry.
+ */
+export interface EnhancementsSettings {
+  /**
+   * The focus rule for spell enhancements.
+   */
+  spell: FocusRule_ID
+
+  /**
+   * The focus rule for liturgical chant enhancements.
+   */
+  liturgicalChant: FocusRule_ID
+}
+
 export interface SexPractice {
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.

package/lib/cache/activatableSelectOptions.js

@@ -102,11 +102,12 @@ const getApValueForSkillish = (config, id, ic) => {
             return assertExhaustive(config);
     }
 };
-const convertSkillApplicationOrUse = (entryId, id, applicationOrUse) => ({
+const convertSkillApplicationOrUse = (entryId, id, applicationOrUse, src) => ({
     id: `${fromUniformCase(entryId)}+${applicationOrUse.id.toFixed()}`,
     content: {
         parent: entryId,
         skills: [id],
+        src,
         translations: applicationOrUse.translations,
     },
 });
@@ -131,7 +132,7 @@ const getSpellworkFilter = (category) => {
             }
         });
 };
-const getDerivedSkillishSelectOptions = (database, entryId, entity, category, options, filter) => {
+const getDerivedSkillishSelectOptions = (database, entryId, entity, category, options, filter, parentSrc) => {
     const { prerequisites } = category;
     const { bindingCost, ap_value } = options;
     const instances = database.getAllInstanceContainersOfEntity(entity);
@@ -150,13 +151,12 @@ const getDerivedSkillishSelectOptions = (database, entryId, entity, category, op
                     name: t10n.name,
                 })),
             },
-            newApplications: category.skill_applications?.map(app => convertSkillApplicationOrUse(entryId, id, app)) ??
-                [],
-            uses: category.skill_uses?.map(use => convertSkillApplicationOrUse(entryId, id, use)) ?? [],
+            newApplications: category.skill_applications?.map(app => convertSkillApplicationOrUse(entryId, id, app, parentSrc)) ?? [],
+            uses: category.skill_uses?.map(use => convertSkillApplicationOrUse(entryId, id, use, parentSrc)) ?? [],
         };
     });
 };
-const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
+const getDerivedSelectOptions = (selectOptionCategory, entryId, database, parentSrc) => {
     switch (selectOptionCategory.kind) {
         case "Blessings":
             return database
@@ -685,15 +685,15 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
                             const matchesIdRequirement = category.Skills.specific === undefined ||
                                 matchesSpecificSkillishIdList(category.Skills.specific, required => required === id);
                             return matchesGroupRequirement && matchesIdRequirement;
-                        });
+                        }, parentSrc);
                     case "Spells":
-                        return getDerivedSkillishSelectOptions(database, entryId, "Spell", category.Spells, selectOptionCategory.Skills, getSpellworkFilter(category.Spells));
+                        return getDerivedSkillishSelectOptions(database, entryId, "Spell", category.Spells, selectOptionCategory.Skills, getSpellworkFilter(category.Spells), parentSrc);
                     case "Rituals":
-                        return getDerivedSkillishSelectOptions(database, entryId, "Ritual", category.Rituals, selectOptionCategory.Skills, getSpellworkFilter(category.Rituals));
+                        return getDerivedSkillishSelectOptions(database, entryId, "Ritual", category.Rituals, selectOptionCategory.Skills, getSpellworkFilter(category.Rituals), parentSrc);
                     case "LiturgicalChants":
-                        return getDerivedSkillishSelectOptions(database, entryId, "LiturgicalChant", category.LiturgicalChants, selectOptionCategory.Skills, getDefaultSkillishFilter(category.LiturgicalChants));
+                        return getDerivedSkillishSelectOptions(database, entryId, "LiturgicalChant", category.LiturgicalChants, selectOptionCategory.Skills, getDefaultSkillishFilter(category.LiturgicalChants), parentSrc);
                     case "Ceremonies":
-                        return getDerivedSkillishSelectOptions(database, entryId, "Ceremony", category.Ceremonies, selectOptionCategory.Skills, getDefaultSkillishFilter(category.Ceremonies));
+                        return getDerivedSkillishSelectOptions(database, entryId, "Ceremony", category.Ceremonies, selectOptionCategory.Skills, getDefaultSkillishFilter(category.Ceremonies), parentSrc);
                     default:
                         return assertExhaustive(category);
                 }
@@ -702,9 +702,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
             return selectOptionCategory.CombatTechniques.categories.flatMap(category => {
                 switch (category.kind) {
                     case "CloseCombatTechniques":
-                        return getDerivedSkillishSelectOptions(database, entryId, "CloseCombatTechnique", category.CloseCombatTechniques, selectOptionCategory.CombatTechniques, getDefaultSkillishFilter(category.CloseCombatTechniques));
+                        return getDerivedSkillishSelectOptions(database, entryId, "CloseCombatTechnique", category.CloseCombatTechniques, selectOptionCategory.CombatTechniques, getDefaultSkillishFilter(category.CloseCombatTechniques), parentSrc);
                     case "RangedCombatTechniques":
-                        return getDerivedSkillishSelectOptions(database, entryId, "RangedCombatTechnique", category.RangedCombatTechniques, selectOptionCategory.CombatTechniques, getDefaultSkillishFilter(category.RangedCombatTechniques));
+                        return getDerivedSkillishSelectOptions(database, entryId, "RangedCombatTechnique", category.RangedCombatTechniques, selectOptionCategory.CombatTechniques, getDefaultSkillishFilter(category.RangedCombatTechniques), parentSrc);
                     default:
                         return assertExhaustive(category);
                 }
@@ -787,14 +787,14 @@ const getExplicitSelectOptions = (id, database) => database
     newApplications: [], // database.getAllChildInstanceContainersForParent("NewSkillApplication", Case("GeneralSelectOption", id)), // prevent duplicates as these can already be queried from the database
     uses: [], // database.getAllChildInstanceContainersForParent("SkillUse", Case("GeneralSelectOption", id)), // prevent duplicates as these can already be queried from the database
 }));
-const getSelectOptions = (selectOptions, id, database) => [
+const getSelectOptions = (selectOptions, id, database, parentSrc) => [
     ...(selectOptions.derived === undefined
         ? []
-        : getDerivedSelectOptions(selectOptions.derived, id, database)),
+        : getDerivedSelectOptions(selectOptions.derived, id, database, parentSrc)),
     ...getExplicitSelectOptions(id, database),
 ];
 const getSelectOptionsForResults = (database, entity, results) => results.reduce((acc, { id, content }) => {
-    const options = getSelectOptions(content.select_options ?? {}, Case(entity, id), database);
+    const options = getSelectOptions(content.select_options ?? {}, Case(entity, id), database, content.src);
     if (options.length > 0) {
         acc[id] = options;
     }

package/lib/cache/newApplicationsAndUses.d.ts

@@ -1,16 +1,18 @@
-import type { ActivatableIdentifier, NewSkillApplication, NewSkillApplicationOrUseParentIdentifier, Skill_ID, SkillUse } from "../../gen/types.js";
+import type { ActivatableIdentifier, NewSkillApplication, NewSkillApplicationOrUseParentIdentifier, PublicationRefs, Skill_ID, SkillUse } from "../../gen/types.js";
 import type { ActivatableSelectOptionsCache } from "./activatableSelectOptions.ts";
 import type { CacheBuilder } from "./internal.ts";
 export type ResolvedNewSkillApplication = {
     id: string;
     content: Omit<NewSkillApplication, "parent"> & {
         parent: NewSkillApplicationOrUseParentIdentifier | ActivatableIdentifier;
+        src: PublicationRefs | undefined;
     };
 };
 export type ResolvedSkillUse = {
     id: string;
     content: Omit<SkillUse, "parent"> & {
         parent: NewSkillApplicationOrUseParentIdentifier | ActivatableIdentifier;
+        src: PublicationRefs | undefined;
     };
 };
 export type NewApplicationsAndUsesCache = {

package/lib/cache/newApplicationsAndUses.js

@@ -1,15 +1,23 @@
-const groupByAffectedSkill = (entries, prev = {}) => entries.reduce((acc, entry) => entry.content.skills.reduce((acc1, skillId) => {
+const groupByAffectedSkill = (database, entries, prev = {}) => entries
+    .map(entry => ({
+    ...entry,
+    content: {
+        ...entry.content,
+        src: database.getInstanceOfEntityById(entry.content.parent)?.src,
+    },
+}))
+    .reduce((acc, entry) => entry.content.skills.reduce((acc1, skillId) => {
     acc1[skillId] = [...(acc1[skillId] ?? []), entry];
     return acc1;
 }, acc), prev);
-const addGeneratedEntries = (generatedSelectOptions, prev) => Object.values(generatedSelectOptions).reduce((acc, byInstance) => Object.values(byInstance).reduce((acc1, resolvedSelectOptions) => resolvedSelectOptions.reduce((acc2, selectOption) => ({
-    newApplications: groupByAffectedSkill(selectOption.newApplications, acc2.newApplications),
-    uses: groupByAffectedSkill(selectOption.uses, acc2.uses),
+const addGeneratedEntries = (database, generatedSelectOptions, prev) => Object.values(generatedSelectOptions).reduce((acc, byInstance) => Object.values(byInstance).reduce((acc1, resolvedSelectOptions) => resolvedSelectOptions.reduce((acc2, selectOption) => ({
+    newApplications: groupByAffectedSkill(database, selectOption.newApplications, acc2.newApplications),
+    uses: groupByAffectedSkill(database, selectOption.uses, acc2.uses),
 }), acc1), acc), prev);
 export const buildNewApplicationsAndUsesCache = (database, _idMap, generatedSelectOptions) => {
     const cache = {
-        newApplications: groupByAffectedSkill(database.getAllInstanceContainersOfEntity("NewSkillApplication")),
-        uses: groupByAffectedSkill(database.getAllInstanceContainersOfEntity("SkillUse")),
+        newApplications: groupByAffectedSkill(database, database.getAllInstanceContainersOfEntity("NewSkillApplication")),
+        uses: groupByAffectedSkill(database, database.getAllInstanceContainersOfEntity("SkillUse")),
     };
-    return addGeneratedEntries(generatedSelectOptions, cache);
+    return addGeneratedEntries(database, generatedSelectOptions, cache);
 };

package/lib/types/Settings.d.ts

@@ -186,6 +186,10 @@ export declare const Settings: DB.SingletonEntity<"Settings", {
         magic: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         liturgical: DB.MemberDecl<DB.ReferenceIdentifier, true>;
     }>, []>>, true>;
+    enhancements: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementsSettings", DB.Object<{
+        spell: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        liturgicalChant: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    }>, []>>, true>;
     extendedBookDescriptionPublication: DB.MemberDecl<DB.ReferenceIdentifier, true>;
     maximumSkillRatingBonusEntry: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
         Adoruzepterzauber: DB.EnumCase<DB.ReferenceIdentifier>;

package/lib/types/Settings.js

@@ -27,6 +27,10 @@ export const Settings = DB.SingletonEntity(import.meta.url, {
             comment: StyleSpecialAbilitySettings.comment,
             type: DB.IncludeIdentifier(StyleSpecialAbilitySettings),
         }),
+        enhancements: DB.Required({
+            comment: EnhancementsSettings.comment,
+            type: DB.IncludeIdentifier(EnhancementsSettings),
+        }),
         extendedBookDescriptionPublication: DB.Required({
             comment: "The publication that extends the description of books with additional information.",
             type: PublicationIdentifier(),
@@ -103,3 +107,17 @@ const StyleSpecialAbilitySettings = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
+const EnhancementsSettings = DB.TypeAlias(import.meta.url, {
+    name: "EnhancementsSettings",
+    comment: "Spell and Liturgical Chant Enhancements are part of focus rules. This type defines which focus rule must be enabled in order to use an enhancement. Essentially, this is a default prerequisite they must meet, but manually inserting them with every enhancement is a lot of work and error-prone. Therefore, in order to use an enhancement, prerequisites for the respective focus rule must be generated for every entry.",
+    type: () => DB.Object({
+        spell: DB.Required({
+            comment: "The focus rule for spell enhancements.",
+            type: FocusRuleIdentifier(),
+        }),
+        liturgicalChant: DB.Required({
+            comment: "The focus rule for liturgical chant enhancements.",
+            type: FocusRuleIdentifier(),
+        }),
+    }),
+});

package/package.json

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