feat!: derived select options based on property

Refs: #175 Closes #174
feat!: active usage type for combat styles
2026-06-27 14:55:52 +02:00 · 2026-06-27 14:06:46 +02:00 · 2026-06-24 22:19:55 +02:00 · 2026-06-21 22:53:25 +02:00 · 2026-06-21 21:46:25 +02:00 · 2026-06-21 21:46:15 +02:00
105 changed files with 1627 additions and 853 deletions
@@ -2,6 +2,203 @@

 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.53.0](https://github.com/Optolith/database-schema/compare/v0.52.2...v0.53.0) (2026-06-21)
+
+
+### ⚠ BREAKING CHANGES
+
+* add bannzeichen cost map
+
+### Features
+
+* add bannzeichen cost map ([0e25dbf](https://github.com/Optolith/database-schema/commit/0e25dbf4a70275b9ba87f1d6b50f8e0c5ac806c1))
+* separate tradition artifact enhancement identifiers ([7e97792](https://github.com/Optolith/database-schema/commit/7e977925b52135859dc4335dcf4238c1271c1a02))
+
+## [0.52.2](https://github.com/Optolith/database-schema/compare/v0.52.1...v0.52.2) (2026-06-21)
+
+
+### Bug Fixes
+
+* combined unique constraint for botanic regions ([249af59](https://github.com/Optolith/database-schema/commit/249af59f6ac7549fa91ad756f8f12d4802593a3a))
+
+## [0.52.1](https://github.com/Optolith/database-schema/compare/v0.52.0...v0.52.1) (2026-06-20)
+
+
+### Features
+
+* optional translation for combat technique restrictions ([1e30f55](https://github.com/Optolith/database-schema/commit/1e30f55407cae829aae2d1a1097c30eff4c68f3a)), closes [#169](https://github.com/Optolith/database-schema/issues/169) [#168](https://github.com/Optolith/database-schema/issues/168)
+
+## [0.52.0](https://github.com/Optolith/database-schema/compare/v0.51.0...v0.52.0) (2026-06-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* enchantment cost map
+
+### Features
+
+* botanic region uniqueness per parent ([3b522aa](https://github.com/Optolith/database-schema/commit/3b522aa9d7a76b1d8dafa3a89b1712ecba4b0c85)), closes [#166](https://github.com/Optolith/database-schema/issues/166) [#165](https://github.com/Optolith/database-schema/issues/165)
+* enchantment cost map ([894fe21](https://github.com/Optolith/database-schema/commit/894fe21536d21c2bbc618ec77279da96f5303f06)), closes [#167](https://github.com/Optolith/database-schema/issues/167) [#164](https://github.com/Optolith/database-schema/issues/164)
+
+## [0.51.0](https://github.com/Optolith/database-schema/compare/v0.50.1...v0.51.0) (2026-06-18)
+
+
+### ⚠ BREAKING CHANGES
+
+* rework plants schema
+
+### Features
+
+* add schemas for goblin tradition artifact enchantments ([da1d245](https://github.com/Optolith/database-schema/commit/da1d2459db003a624cce4d84c2695b927d7476f0)), closes [#163](https://github.com/Optolith/database-schema/issues/163) [#162](https://github.com/Optolith/database-schema/issues/162)
+* rework plants schema ([6c62616](https://github.com/Optolith/database-schema/commit/6c6261628583cda5a27d34c194e5aae69c38a079)), closes [#161](https://github.com/Optolith/database-schema/issues/161) [#160](https://github.com/Optolith/database-schema/issues/160)
+
+## [0.50.1](https://github.com/Optolith/database-schema/compare/v0.50.0...v0.50.1) (2026-06-14)
+
+
+### Features
+
+* primary blessing for tradition ([9d97dd4](https://github.com/Optolith/database-schema/commit/9d97dd4ec95c8dd42cb6e31873a4702684a941de))
+* trade secrets for herbal aids ([27236a7](https://github.com/Optolith/database-schema/commit/27236a75884fdb891a60a0105ebb5ff82147cbc1)), closes [#159](https://github.com/Optolith/database-schema/issues/159) [#158](https://github.com/Optolith/database-schema/issues/158)
+
+## [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)
+
+
+### ⚠ BREAKING CHANGES
+
+* unify some skill durations and ranges with expressions
+
+### Features
+
+* unify some skill durations and ranges with expressions ([31798ca](https://github.com/Optolith/database-schema/commit/31798ca33fab12b1d1c0c6edec0c543173c8f4ac))
+
+## [0.47.4](https://github.com/Optolith/database-schema/compare/v0.47.3...v0.47.4) (2026-06-13)
+
+
+### Features
+
+* culture language translations ([b5ece95](https://github.com/Optolith/database-schema/commit/b5ece951032138b19cb02dfc8172177bd337b37f))
+
+## [0.47.3](https://github.com/Optolith/database-schema/compare/v0.47.2...v0.47.3) (2026-06-13)
+
+
+### Features
+
+* level and options for automatic and str. rec. dis/advantages in sub-races ([a7b8e7e](https://github.com/Optolith/database-schema/commit/a7b8e7ec0c6c1c90b8a656b9b19cd156d403382b)), closes [#150](https://github.com/Optolith/database-schema/issues/150)
+* optional sources for skill applications ([cdb86e9](https://github.com/Optolith/database-schema/commit/cdb86e9aa6768601c9f017f01bde6d70108db083))
+
+
+### Bug Fixes
+
+* profession cantrips must be unique ([6c9f7a6](https://github.com/Optolith/database-schema/commit/6c9f7a6ec2bafb35c40680d1199739f1b435e6a9))
+
+## [0.47.2](https://github.com/Optolith/database-schema/compare/v0.47.1...v0.47.2) (2026-06-08)
+
+
+### Features
+
+* optional target category for animist powers ([aa556a4](https://github.com/Optolith/database-schema/commit/aa556a48c842fabc80b2564c15743fc68b730668))
+
+## [0.47.1](https://github.com/Optolith/database-schema/compare/v0.47.0...v0.47.1) (2026-06-08)
+
+
+### Features
+
+* skill check penalty for animist powers ([9ed6e70](https://github.com/Optolith/database-schema/commit/9ed6e7064587aaf3ac297c31f116b4eb64889b61))
+
+
+### Bug Fixes
+
+* personality trait effect supports markdown ([af43af8](https://github.com/Optolith/database-schema/commit/af43af87de963623527e5f0e6d0071d2cd09d7bc))
+
+## [0.47.0](https://github.com/Optolith/database-schema/compare/v0.46.0...v0.47.0) (2026-06-07)
+
+
+### ⚠ BREAKING CHANGES
+
+* interval for sustained cost map
+* personality trait as activatable prerequisite
+
+### Features
+
+* fixed cantrips for base profession package ([737fe37](https://github.com/Optolith/database-schema/commit/737fe3742cdec7997dbb011872d3a0484bb58bfc)), closes [#148](https://github.com/Optolith/database-schema/issues/148)
+* note for commonness-rated entries ([1f28470](https://github.com/Optolith/database-schema/commit/1f28470b8fd0516bb1ac3507d3397e8afd6d6378)), closes [#146](https://github.com/Optolith/database-schema/issues/146)
+* personality trait as activatable prerequisite ([d4ffbb9](https://github.com/Optolith/database-schema/commit/d4ffbb911165b2bb485d68e6d9b114e5dbce7a2f))
+
+
+### Bug Fixes
+
+* interval for sustained cost map ([4c2228b](https://github.com/Optolith/database-schema/commit/4c2228b6d7214bc3b9bb3b4f19bf1ac20cff0a76)), closes [#145](https://github.com/Optolith/database-schema/issues/145)
+
+## [0.46.0](https://github.com/Optolith/database-schema/compare/v0.45.0...v0.46.0) (2026-06-07)
+
+
+### ⚠ BREAKING CHANGES
+
+* allow blessed profession
+
+### Features
+
+* allow blessed profession ([47f9e89](https://github.com/Optolith/database-schema/commit/47f9e890bbc46b37e36ef55b0cfcbecef2a3ef44))
+* plants entity ([ae45659](https://github.com/Optolith/database-schema/commit/ae45659ff94656f60dfa803257927e6b11289c92)), closes [#142](https://github.com/Optolith/database-schema/issues/142) [#3](https://github.com/Optolith/database-schema/issues/3)
+* use library name as display name if available ([a9ea59a](https://github.com/Optolith/database-schema/commit/a9ea59a8023ea770af45ac6a913c3c70c4f0bc04))
+
+
+### Bug Fixes
+
+* required language specializations ([96d70f7](https://github.com/Optolith/database-schema/commit/96d70f7237cfae07e24ead363b00d7bee795e47d))
+
+## [0.45.0](https://github.com/Optolith/database-schema/compare/v0.44.1...v0.45.0) (2026-05-31)
+
+
+### ⚠ BREAKING CHANGES
+
+* add maximum sr translation
+
+### Features
+
+* add maximum sr translation ([64e7ed1](https://github.com/Optolith/database-schema/commit/64e7ed10358a26028c7c1db79a8b9a1d4bce91c5))
+
+## [0.44.1](https://github.com/Optolith/database-schema/compare/v0.44.0...v0.44.1) (2026-05-31)
+
+
+### Features
+
+* full commonness-rated text replacement ([c147d16](https://github.com/Optolith/database-schema/commit/c147d1613090fc76689bf98891c06e81ee8bf962))
+
+## [0.44.0](https://github.com/Optolith/database-schema/compare/v0.43.3...v0.44.0) (2026-05-30)
+
+
+### ⚠ BREAKING CHANGES
+
+* diease and poison options can be required
+
+### Features
+
+* diease and poison options can be required ([7fc5fd1](https://github.com/Optolith/database-schema/commit/7fc5fd144adeb561a737bb01bf2d989ea2b3acd6))
+
 ## [0.43.3](https://github.com/Optolith/database-schema/compare/v0.43.2...v0.43.3) (2026-05-30)


@@ -1,15 +1,15 @@
 {
  "name": "@optolith/database-schema",
-  "version": "0.43.3",
+  "version": "0.53.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@optolith/database-schema",
-      "version": "0.43.3",
+      "version": "0.53.0",
      "license": "MPL-2.0",
      "dependencies": {
-        "@elyukai/utils": "^0.3.4",
+        "@elyukai/utils": "^0.3.6",
        "tsondb": "^0.20.3",
        "yaml": "^2.9.0"
      },
@@ -60,9 +60,9 @@
      }
    },
    "node_modules/@elyukai/utils": {
-      "version": "0.3.4",
-      "resolved": "https://registry.npmjs.org/@elyukai/utils/-/utils-0.3.4.tgz",
-      "integrity": "sha512-zqBF3Nz7Pd5e35E2mZuImeAvCSRlAneIWb/gZKtaa9yX1oPTW/4uVKrK5k7QE9pR7xMPo7FTUs2jZ5ZDaZ75PA==",
+      "version": "0.3.6",
+      "resolved": "https://registry.npmjs.org/@elyukai/utils/-/utils-0.3.6.tgz",
+      "integrity": "sha512-SFij3T0baqFu+G5NGjlHPVpLtKEeVRKg59jiMr7wQwAYM7LLpgoArBLeM/UL98FM0ntmvaRDDEBCfyMcCnsxdA==",
      "license": "MPL-2.0"
    },
    "node_modules/@eslint-community/eslint-utils": {
@@ -1,6 +1,6 @@
 {
  "name": "@optolith/database-schema",
-  "version": "0.43.3",
+  "version": "0.53.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",
@@ -38,7 +38,7 @@
  "author": "Lukas Obermann",
  "license": "MPL-2.0",
  "dependencies": {
-    "@elyukai/utils": "^0.3.4",
+    "@elyukai/utils": "^0.3.6",
    "tsondb": "^0.20.3",
    "yaml": "^2.9.0"
  },
@@ -17,7 +17,9 @@ import type {
  ImprovementCost,
  Poison,
  PrerequisiteForLevel,
+  Property_ID,
  RequirableSelectOptionIdentifier,
+  Ritual_ID,
  SelectOptionCategory,
  SelectOptions,
  SelectOptionsAdventurePointsValue,
@@ -28,6 +30,7 @@ import type {
  SkillSelectOptionCategoryPrerequisite,
  SpecificFromSkillSelectOptionCategoryCategory,
  SpecificTargetCategory,
+  Spell_ID,
  TargetCategory,
  TradeSecretAdventurePointsValue,
 } from "../../gen/types.js"
@@ -67,15 +70,17 @@ const wrapPlainApValue = (
 ): TradeSecretAdventurePointsValue | undefined =>
  apValue === undefined ? undefined : Case("Fixed", apValue)

-const matchesSpecificSkillishIdList = (
-  id: string,
-  config: SpecificFromSkillSelectOptionCategoryCategory<string>,
+const matchesSpecificSkillishIdList = <Ref>(
+  config: SpecificFromSkillSelectOptionCategoryCategory<Ref>,
+  matches: (required: Ref) => boolean,
 ): boolean => {
+  const isInList = config.list.some(matches)
+
  switch (config.operation.kind) {
    case "Intersection":
-      return config.list.includes(id)
+      return isInList
    case "Difference":
-      return !config.list.includes(id)
+      return !isInList
    default:
      return assertExhaustive(config.operation)
  }
@@ -233,14 +238,35 @@ const getDefaultSkillishFilter = <E extends SkillishEntityName>(
  const { specific } = category
  return specific === undefined
    ? undefined
-    : ({ id }) => matchesSpecificSkillishIdList(id, specific)
+    : ({ id }) => matchesSpecificSkillishIdList(specific, required => required === id)
 }

-const getDerivedSkillishSelectOptions = <E extends SkillishEntityName>(
+const getSpellworkFilter = <E extends "Spell" | "Ritual">(
+  category: GenericSkillsSelectOptionCategoryCategory<
+    Case<"Single", Spell_ID | Ritual_ID> | Case<"Property", Property_ID>
+  >,
+): ((instance: { id: string; content: Entity<TSONDBTypes, E> }) => boolean) | undefined => {
+  const { specific } = category
+  return specific === undefined
+    ? undefined
+    : ({ id, content: { property } }) =>
+        matchesSpecificSkillishIdList(specific, required => {
+          switch (required.kind) {
+            case "Single":
+              return required.Single === id
+            case "Property":
+              return property === required.Property
+            default:
+              return assertExhaustive(required)
+          }
+        })
+}
+
+const getDerivedSkillishSelectOptions = <E extends SkillishEntityName, ID>(
  database: TSONDB<TSONDBTypes>,
  entryId: ActivatableIdentifier,
  entity: E,
-  category: GenericSkillsSelectOptionCategoryCategory<string> & {
+  category: GenericSkillsSelectOptionCategoryCategory<ID> & {
    skill_applications?: SkillApplicationOrUse[] | undefined
    skill_uses?: SkillApplicationOrUse[] | undefined
  },
@@ -248,7 +274,7 @@ const getDerivedSkillishSelectOptions = <E extends SkillishEntityName>(
    bindingCost?: SelectOptionsBindingCostValue<SkillishIdentifier | CombatTechniqueIdentifier>
    ap_value?: SelectOptionsAdventurePointsValue<SkillishIdentifier | CombatTechniqueIdentifier>
  },
-  filter = getDefaultSkillishFilter<E>(category),
+  filter: ((instance: { id: string; content: Entity<TSONDBTypes, E> }) => boolean) | undefined,
 ) => {
  const { prerequisites } = category
  const { bindingCost, ap_value } = options
@@ -928,7 +954,10 @@ const getDerivedSelectOptions = (

                const matchesIdRequirement =
                  category.Skills.specific === undefined ||
-                  matchesSpecificSkillishIdList(id, category.Skills.specific)
+                  matchesSpecificSkillishIdList(
+                    category.Skills.specific,
+                    required => required === id,
+                  )

                return matchesGroupRequirement && matchesIdRequirement
              },
@@ -940,6 +969,7 @@ const getDerivedSelectOptions = (
              "Spell",
              category.Spells,
              selectOptionCategory.Skills,
+              getSpellworkFilter(category.Spells),
            )
          case "Rituals":
            return getDerivedSkillishSelectOptions(
@@ -948,6 +978,7 @@ const getDerivedSelectOptions = (
              "Ritual",
              category.Rituals,
              selectOptionCategory.Skills,
+              getSpellworkFilter(category.Rituals),
            )
          case "LiturgicalChants":
            return getDerivedSkillishSelectOptions(
@@ -956,6 +987,7 @@ const getDerivedSelectOptions = (
              "LiturgicalChant",
              category.LiturgicalChants,
              selectOptionCategory.Skills,
+              getDefaultSkillishFilter(category.LiturgicalChants),
            )
          case "Ceremonies":
            return getDerivedSkillishSelectOptions(
@@ -964,6 +996,7 @@ const getDerivedSelectOptions = (
              "Ceremony",
              category.Ceremonies,
              selectOptionCategory.Skills,
+              getDefaultSkillishFilter(category.Ceremonies),
            )
          default:
            return assertExhaustive(category)
@@ -980,6 +1013,7 @@ const getDerivedSelectOptions = (
              "CloseCombatTechnique",
              category.CloseCombatTechniques,
              selectOptionCategory.CombatTechniques,
+              getDefaultSkillishFilter(category.CloseCombatTechniques),
            )
          case "RangedCombatTechniques":
            return getDerivedSkillishSelectOptions(
@@ -988,6 +1022,7 @@ const getDerivedSelectOptions = (
              "RangedCombatTechnique",
              category.RangedCombatTechniques,
              selectOptionCategory.CombatTechniques,
+              getDefaultSkillishFilter(category.RangedCombatTechniques),
            )
          default:
            return assertExhaustive(category)
@@ -1118,8 +1153,10 @@ const cacheKeyBase: Record<ActivatableIdentifier["kind"], null> = {
  FoolsHatEnchantment: null,
  GeneralSpecialAbility: null,
  Haubenzauber: null,
+  Hauerkettenzauber: null,
  InstrumentEnchantment: null,
  KarmaSpecialAbility: null,
+  Keulenzauber: null,
  Krallenkettenzauber: null,
  Kristallkugelzauber: null,
  LiturgicalStyleSpecialAbility: null,
@@ -1132,6 +1169,7 @@ const cacheKeyBase: Record<ActivatableIdentifier["kind"], null> = {
  PactGift: null,
  ProtectiveWardingCircleSpecialAbility: null,
  RingEnchantment: null,
+  Schweinetrommelzauber: null,
  Sermon: null,
  SexSpecialAbility: null,
  SickleRitual: null,
@@ -87,6 +87,7 @@ const isPrerequisiteFor = (
    case "Text":
    case "NoOtherAncestorBloodAdvantage":
    case "SexualCharacteristic":
+    case "PersonalityTrait":
      return false
    default:
      return assertExhaustive(prerequisite)
@@ -47,9 +47,11 @@ export const schema = new Schema<TSONDBTypes>(
    Types.BandageOrRemedy,
    Types.Bannzeichen,
    Types.Beutelzauber,
+    Types.Biome,
    Types.BlessedTradition,
    Types.Blessing,
    Types.Book,
+    Types.BotanicRegion,
    Types.BowlEnchantment,
    Types.BrawlingSpecialAbility,
    Types.Brew,
@@ -96,7 +98,10 @@ export const schema = new Schema<TSONDBTypes>(
    Types.GoblinRitual,
    Types.Guideline,
    Types.HairColor,
+    Types.Hauerkettenzauber,
    Types.Haubenzauber,
+    Types.HerbalAid,
+    Types.HerbalPreservation,
    Types.HomunculusType,
    Types.IlluminationLightSource,
    Types.IlluminationRefillOrSupply,
@@ -104,6 +109,7 @@ export const schema = new Schema<TSONDBTypes>(
    Types.JesterTrick,
    Types.Jewelry,
    Types.KarmaSpecialAbility,
+    Types.Keulenzauber,
    Types.Krallenkettenzauber,
    Types.Kristallkugelzauber,
    Types.Laboratory,
@@ -133,6 +139,7 @@ export const schema = new Schema<TSONDBTypes>(
    Types.PatronCategory,
    Types.PersonalityTrait,
    Types.PlayerType,
+    Types.Plant,
    Types.Poison,
    Types.Profession,
    Types.Property,
@@ -145,6 +152,7 @@ export const schema = new Schema<TSONDBTypes>(
    Types.RingEnchantment,
    Types.Ritual,
    Types.RopeOrChain,
+    Types.Schweinetrommelzauber,
    Types.Script,
    Types.Sermon,
    Types.Service,
@@ -162,6 +170,7 @@ export const schema = new Schema<TSONDBTypes>(
    Types.StaffEnchantment,
    Types.State,
    Types.Stationery,
+    Types.SubBiome,
    Types.Subject,
    Types.Talisman,
    Types.TargetCategory,
@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl"
 import { input, levels, maximum, name, name_in_library, range_l10n, rules } from "./_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "./_ActivatableAdventurePointsValue.js"
 import { automatic_entries } from "./_ActivatableAutomatic.js"
-import { nameBuilderRules } from "./_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "./_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "./_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "./_ActivatableSkillApplicationsAndUses.js"
 import { AdvantageDisadvantagePrerequisites } from "./_Prerequisite.js"
@@ -55,6 +55,7 @@ export const Advantage = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -146,6 +146,25 @@ const CultureLanguage = DB.TypeAlias(import.meta.url, {
        comment: "The language specializations, if any.",
        type: DB.Array(LanguageSpecializationIdentifier(), { minItems: 1, uniqueItems: true }),
      }),
+      translations: NestedTranslationMap(
+        DB.Optional,
+        "CultureLanguage",
+        DB.Object(
+          {
+            specialization: DB.Optional({
+              comment:
+                "The concrete language specialization, if the language allows to specify arbitrary text.",
+              type: DB.String({ minLength: 1 }),
+            }),
+            specializationPrompt: DB.Optional({
+              comment:
+                "A different promt fro the language specialization, if the language allows to specify arbitrary text.",
+              type: DB.String({ minLength: 1 }),
+            }),
+          },
+          { minProperties: 1 },
+        ),
+      ),
    }),
 })

@@ -307,6 +326,7 @@ const BlessedCommonProfessionConstraint = DB.Enum(import.meta.url, {
  name: "BlessedCommonProfessionConstraint",
  values: () => ({
    Tradition: DB.EnumCase({ type: DB.IncludeIdentifier(BlessedTraditionConstraint) }),
+    Profession: DB.EnumCase({ type: DB.IncludeIdentifier(ProfessionConstraint) }),
  }),
 })

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { input, levels, maximum, name, name_in_library, rules } from "./_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "./_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "./_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "./_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "./_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "./_ActivatableSkillApplicationsAndUses.js"
 import { AdvantageDisadvantagePrerequisites } from "./_Prerequisite.js"
@@ -56,6 +56,7 @@ export const Disadvantage = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -6,7 +6,7 @@ import {
 } from "./_ActivatableSkillCost.js"
 import {
  DurationUnitValue,
-  FixedDuration,
+  ExpressionBasedDuration,
  IndefiniteDuration,
 } from "./_ActivatableSkillDuration.js"
 import {
@@ -188,7 +188,7 @@ const FamiliarsTrickOneTimeDuration = DB.Enum(import.meta.url, {
  name: "FamiliarsTrickOneTimeDuration",
  values: () => ({
    Immediate: DB.EnumCase({ type: null }),
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedDuration) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
    Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteDuration) }),
  }),
 })
@@ -1042,6 +1042,12 @@ export const Locale = DB.Entity(import.meta.url, {
          ".input {$value :number} .input {$style :string} {{{$value} years}}": null,
          "{$value} years": null,
          "years": null,
+          ".input {$value :number} .input {$style :string} {{{$value} dcs.}}": null,
+          "{$value} dcs.": null,
+          "dcs.": null,
+          ".input {$value :number} .input {$style :string} {{{$value} decades}}": null,
+          "{$value} decades": null,
+          "decades": null,
          ".input {$value :number} .input {$style :string} {{{$value} cent.}}": null,
          "{$value} cent.": null,
          "cent.": null,
@@ -1422,6 +1428,7 @@ export const Locale = DB.Entity(import.meta.url, {
          "Aspect": null,
          "As chosen": null,
          "Passive": null,
+          "Active": null,
          "Basic Maneuver": null,
          "Special Maneuver": null,
          "Volume": null,
@@ -1721,6 +1728,7 @@ export const Locale = DB.Entity(import.meta.url, {
          "no Liturgies totaling {$apValue} AP": null,
          "{$apValue} AP to improve other {$skillsOfGroup}": null,
          "{$apValue} AP to distribute among the following skills: {$list}": null,
+          "maximum SR per skill: {$maxSR}": null,
          "no AP to improve other {$skillsOfGroup}": null,
          ".input {$count :number} {{{$count} cantrips}}": null,
          "{$count} from the following list": null,
@@ -62,7 +62,7 @@ const PersonalityTraitEffect = DB.TypeAlias(import.meta.url, {
      }),
      text: DB.Required({
        comment: "The effect text.",
-        type: DB.String({ minLength: 1 }),
+        type: DB.String({ minLength: 1, markdown: "inline" }),
      }),
    }),
 })
@@ -255,6 +255,10 @@ export const ProfessionPackage = DB.Entity(import.meta.url, {
        comment: "The skill ratings the package grants to the hero.",
        type: DB.Array(DB.IncludeIdentifier(SkillRating), { minItems: 1 }),
      }),
+      cantrips: DB.Optional({
+        comment: "The cantrips the profession receives from the package.",
+        type: DB.Array(CantripIdentifier(), { minItems: 1, uniqueItems: true }),
+      }),
      spells: DB.Optional({
        comment:
          "The skill ratings a magical profession receives for spells; these spells are considered activated. Spells from an unfamiliar Tradition, if any, are identified as such.",
@@ -11,6 +11,7 @@ import {
  HairColorIdentifier,
  RaceIdentifier,
 } from "./_Identifier.js"
+import { RequirableSelectOptionIdentifier } from "./_IdentifierGroup.js"
 import { calculationContainsRaceBase, DerivedCharacteristic } from "./DerivedCharacteristic.ts"
 import { ExperienceLevel } from "./ExperienceLevel.js"
 import { NestedTranslationMap } from "./Locale.js"
@@ -195,6 +196,15 @@ const AutomaticAdvantageDisadvantage = DB.GenTypeAlias(import.meta.url, {
        comment: "The automatic advantage or disadvantage.",
        type: DB.TypeArgument(Identifier),
      }),
+      level: DB.Optional({
+        comment: "The level of the entry.",
+        type: DB.Integer({ minimum: 1 }),
+      }),
+      options: DB.Optional({
+        comment:
+          "Required select options. Order is important. Typically, you only need the first array index, though.",
+        type: DB.Array(DB.IncludeIdentifier(RequirableSelectOptionIdentifier), { minItems: 1 }),
+      }),
    }),
 })

@@ -265,8 +275,7 @@ export const RaceVariant = DB.Entity(import.meta.url, {
        type: DB.Array(CultureIdentifier(), { minItems: 1 }),
      }),
      automatic_advantages: DB.Optional({
-        comment:
-          "A list of automatically applied advantages. This does only work for advantages with no further configuration such as level or special selection.",
+        comment: "A list of automatically applied advantages.",
        type: DB.Array(
          DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [AdvantageIdentifier()]),
          {
@@ -275,8 +284,7 @@ export const RaceVariant = DB.Entity(import.meta.url, {
        ),
      }),
      automatic_disadvantages: DB.Optional({
-        comment:
-          "A list of automatically applied disadvantages. This does only work for disadvantages with no further configuration such as level or special selection.",
+        comment: "A list of automatically applied disadvantages.",
        type: DB.Array(
          DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [DisadvantageIdentifier()]),
          { minItems: 1 },
@@ -285,14 +293,14 @@ export const RaceVariant = DB.Entity(import.meta.url, {
      strongly_recommended_advantages: DB.Optional({
        comment: "A list of strongly recommended advantages.",
        type: DB.Array(
-          DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [AdvantageIdentifier()]),
+          DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [AdvantageIdentifier()]),
          { minItems: 1 },
        ),
      }),
      strongly_recommended_disadvantages: DB.Optional({
        comment: "A list of strongly recommended disadvantages.",
        type: DB.Array(
-          DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [DisadvantageIdentifier()]),
+          DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [DisadvantageIdentifier()]),
          { minItems: 1 },
        ),
      }),
@@ -8,7 +8,7 @@ import { ImprovementCost } from "./_ImprovementCost.js"
 import { SkillCheck } from "./_SkillCheck.js"
 import { NestedTranslationMap } from "./Locale.js"
 import { Errata } from "./source/_Erratum.js"
-import { src } from "./source/_PublicationRef.js"
+import { optionalSrc, src } from "./source/_PublicationRef.js"

 export const Skill = DB.Entity(import.meta.url, {
  name: "Skill",
@@ -125,6 +125,7 @@ export const SkillApplication = DB.Entity(import.meta.url, {
        comment: "The skill this application belongs to.",
        type: SkillIdentifier(),
      }),
+      src: optionalSrc,
      translations: NestedTranslationMap(
        DB.Required,
        "SkillApplication",
@@ -15,6 +15,12 @@ export const name_in_library = DB.Optional({
  type: DB.String({ minLength: 1 }),
 })

+export const additionalName = DB.Optional({
+  comment:
+    "A part of the name that is appended in parenthesis. This can be used to specify the group of people that typically uses this entry (e.g. the name of the witch circle for a magic style for witches).\n\nIf `name_in_library` is specified, this will be ignored for places where the `name_in_library` is used.",
+  type: DB.String({ minLength: 1 }),
+})
+
 export const levels = DB.Optional({
  comment: "Number of available levels.",
  type: DB.Integer({ minimum: 2 }),
@@ -9,6 +9,7 @@ import {
  CombatRelatedSpecialAbilityIdentifier,
  CombatTechniqueIdentifier,
 } from "./_IdentifierGroup.js"
+import { NestedTranslationMap } from "./Locale.js"

 const CombatSpecialAbilityUsageType = DB.Enum(import.meta.url, {
  name: "CombatSpecialAbilityUsageType",
@@ -20,11 +21,25 @@ const CombatSpecialAbilityUsageType = DB.Enum(import.meta.url, {
  }),
 })

-export const usage_type = DB.Required({
+const CombatStyleUsageType = DB.Enum(import.meta.url, {
+  name: "CombatSpecialAbilityTypeUsageType",
+  comment: "The definition of how the combat special ability style can be used in combat.",
+  values: () => ({
+    Passive: DB.EnumCase({ type: null }),
+    Active: DB.EnumCase({ type: null }),
+  }),
+})
+
+export const special_ability_usage_type = DB.Required({
  comment: "The definition of how the combat special ability can be used in combat.",
  type: DB.IncludeIdentifier(CombatSpecialAbilityUsageType),
 })

+export const style_usage_type = DB.Required({
+  comment: "The definition of how the combat style can be used in combat.",
+  type: DB.IncludeIdentifier(CombatStyleUsageType),
+})
+
 const CombatSpecialAbilityType = DB.Enum(import.meta.url, {
  name: "CombatSpecialAbilityType",
  comment:
@@ -323,6 +338,16 @@ const SpecificApplicableCombatTechnique = DB.TypeAlias(import.meta.url, {
      restriction: DB.Optional({
        type: DB.IncludeIdentifier(ApplicableSpecificCombatTechniquesRestriction),
      }),
+      translation: NestedTranslationMap(
+        DB.Optional,
+        "SpecificApplicableCombatTechnique",
+        DB.Object({
+          restriction: DB.Required({
+            comment: "The additional restriction of the combat technique.",
+            type: DB.String({ minLength: 1, markdown: "inline" }),
+          }),
+        }),
+      ),
      weapons: DB.Optional({
        comment: "The specific weapons this combat special ability is only applicable to.",
        type: DB.Array(WeaponIdentifier(), { minItems: 1 }),
@@ -31,3 +31,26 @@ const ActivatableNameLevelPlacement = DB.Enum(import.meta.url, {
    AfterOptions: DB.EnumCase({ type: null }),
  }),
 })
+
+export const activatableDisplayNameCustomizer = ({
+  instance,
+  instanceDisplayName,
+  instanceDisplayNameLocaleId,
+  locales,
+}: {
+  instance: { translations: Record<string, { name: string; name_in_library?: string }> }
+  instanceDisplayName: string
+  instanceDisplayNameLocaleId: string | undefined
+  locales: string[]
+}) => {
+  for (const locale of locales) {
+    const translation = instance.translations[locale]
+    if (translation) {
+      return {
+        name: translation.name_in_library ?? translation.name,
+        localeId: locale,
+      }
+    }
+  }
+  return { name: instanceDisplayName, localeId: instanceDisplayNameLocaleId }
+}
@@ -4,6 +4,7 @@ import { DurationUnitValue } from "./_ActivatableSkillDuration.js"
 import { AspectIdentifier, PropertyIdentifier } from "./_Identifier.js"
 import { VolumePointsOptionReferenceIdentifier } from "./_IdentifierGroup.js"
 import { ResponsiveText, ResponsiveTextOptional } from "./_ResponsiveText.js"
+import { OneTimeCostMap } from "./_ActivatableSkillCost.js"

 const EnchantmentCost = DB.Enum(import.meta.url, {
  name: "EnchantmentCost",
@@ -13,6 +14,11 @@ const EnchantmentCost = DB.Enum(import.meta.url, {
  }),
 })

+export const cost_note = DB.Optional({
+  comment: "A note, appended to the generated cost string in parenthesis.",
+  type: DB.IncludeIdentifier(ResponsiveTextOptional),
+})
+
 export const cost = DB.Optional({
  comment: "The cost when casting the entry.",
  type: DB.IncludeIdentifier(EnchantmentCost),
@@ -32,6 +38,7 @@ export const ArcaneEnergyCost = DB.Enum(import.meta.url, {
    Disjunction: DB.EnumCase({ type: DB.IncludeIdentifier(ArcaneEnergyCostDisjunction) }),
    Variable: DB.EnumCase({ type: null }),
    ByLevel: DB.EnumCase({ type: DB.IncludeIdentifier(ArcaneEnergyCostByLevel) }),
+    Map: DB.EnumCase({ type: DB.IncludeIdentifier(OneTimeCostMap) }),
  }),
 })

@@ -11,6 +11,7 @@ import {
  SkillIdentifier,
  SpellIdentifier,
  TargetCategoryIdentifier,
+  PropertyIdentifier,
 } from "./_Identifier.js"
 import {
  ActivatableIdentifier,
@@ -211,16 +212,34 @@ const SkillsSelectOptionCategory = DB.TypeAlias(import.meta.url, {
    }),
 })

+const SpellFilter = DB.Enum(import.meta.url, {
+  name: "SpellFilter",
+  values: () => ({
+    Single: DB.EnumCase({ type: SpellIdentifier() }),
+    Property: DB.EnumCase({ type: PropertyIdentifier() }),
+  }),
+})
+
+const RitualFilter = DB.Enum(import.meta.url, {
+  name: "RitualFilter",
+  values: () => ({
+    Single: DB.EnumCase({ type: RitualIdentifier() }),
+    Property: DB.EnumCase({ type: PropertyIdentifier() }),
+  }),
+})
+
 const SkillsSelectOptionCategoryCategory = DB.Enum(import.meta.url, {
  name: "SkillsSelectOptionCategoryCategory",
  values: () => ({
    Skills: DB.EnumCase({ type: DB.IncludeIdentifier(SkillSelectOptionCategoryCategory) }),
    Spells: DB.EnumCase({
-      type: DB.GenIncludeIdentifier(GenericSkillsSelectOptionCategoryCategory, [SpellIdentifier()]),
+      type: DB.GenIncludeIdentifier(GenericSkillsSelectOptionCategoryCategory, [
+        DB.IncludeIdentifierType(SpellFilter),
+      ]),
    }),
    Rituals: DB.EnumCase({
      type: DB.GenIncludeIdentifier(GenericSkillsSelectOptionCategoryCategory, [
-        RitualIdentifier(),
+        DB.IncludeIdentifierType(RitualFilter),
      ]),
    }),
    LiturgicalChants: DB.EnumCase({
@@ -7,6 +7,7 @@ import { FastCastingTime, SlowCastingTime } from "./_ActivatableSkillCastingTime
 import { OneTimeCost, SustainedCost } from "./_ActivatableSkillCost.js"
 import { DurationForOneTime, DurationForSustained } from "./_ActivatableSkillDuration.js"
 import { Range } from "./_ActivatableSkillRange.js"
+import { MathOperation } from "./_MathExpression.ts"

 export const OneTimePerformanceParameters = DB.GenTypeAlias(import.meta.url, {
  name: "OneTimePerformanceParameters",
@@ -104,3 +105,21 @@ export const OldParameter = DB.TypeAlias(import.meta.url, {
      }),
    }),
 })
+
+export const ExpressionBasedParameterValue = DB.TypeAlias(import.meta.url, {
+  name: "ExpressionBasedParameterValue",
+  type: () =>
+    DB.GenIncludeIdentifier(MathOperation, [
+      DB.IncludeIdentifier(ExpressionBasedParameterExpressionValue),
+    ]),
+})
+
+const ExpressionBasedParameterExpressionValue = DB.Enum(import.meta.url, {
+  name: "ExpressionBasedParameterExpressionValue",
+  values: () => ({
+    Constant: DB.EnumCase({ type: DB.Integer({ minimum: 1 }) }),
+    QualityLevels: DB.EnumCase({ type: null }),
+    SkillPoints: DB.EnumCase({ type: null }),
+    SkillRating: DB.EnumCase({ type: null }),
+  }),
+})
@@ -1,15 +1,5 @@
 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.",
@@ -33,19 +23,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),
-      }),
-    }),
-})
@@ -304,6 +304,10 @@ The \`an item the size of a\` would be the *list prefix* string, while the list
          minItems: 2,
        }),
      }),
+      interval: DB.Required({
+        comment: "The sustain interval.",
+        type: DB.IncludeIdentifier(DurationUnitValue),
+      }),
      translations: NestedTranslationMap(
        DB.Optional,
        "SustainedCostMap",
@@ -1,5 +1,5 @@
 import * as DB from "tsondb/schema/dsl"
-import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js"
+import { ExpressionBasedParameterValue } from "./_ActivatableSkill.ts"
 import { ResponsiveText, ResponsiveTextReplace } from "./_ResponsiveText.js"
 import { NestedTranslationMap } from "./Locale.js"

@@ -8,8 +8,7 @@ export const DurationForOneTime = DB.Enum(import.meta.url, {
  values: () => ({
    Immediate: DB.EnumCase({ type: DB.IncludeIdentifier(Immediate) }),
    Permanent: DB.EnumCase({ type: DB.IncludeIdentifier(PermanentDuration) }),
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedDuration) }),
-    CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
    Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteDuration) }),
  }),
 })
@@ -84,21 +83,17 @@ export const FixedDuration = DB.TypeAlias(import.meta.url, {
    }),
 })

-export const CheckResultBasedDuration = DB.TypeAlias(import.meta.url, {
-  name: "CheckResultBasedDuration",
+export const ExpressionBasedDuration = DB.TypeAlias(import.meta.url, {
+  name: "ExpressionBasedDuration",
  type: () =>
    DB.Object({
      is_maximum: DB.Optional({
        comment: "If the duration is the maximum duration, so it may end earlier.",
        type: DB.Boolean(),
      }),
-      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),
+      value: DB.Required({
+        comment: "An expression that evaluates to the duration.",
+        type: DB.IncludeIdentifier(ExpressionBasedParameterValue),
      }),
      unit: DB.Required({
        comment: "The duration unit.",
@@ -106,7 +101,7 @@ export const CheckResultBasedDuration = DB.TypeAlias(import.meta.url, {
      }),
      translations: NestedTranslationMap(
        DB.Optional,
-        "CheckResultBasedDuration",
+        "ExpressionBasedDuration",
        DB.Object({
          replacement: DB.Optional({
            comment: "A replacement string.",
@@ -155,6 +150,7 @@ export const DurationUnit = DB.Enum(import.meta.url, {
    Weeks: DB.EnumCase({ type: null }),
    Months: DB.EnumCase({ type: null }),
    Years: DB.EnumCase({ type: null }),
+    Decades: DB.EnumCase({ type: null }),
    Centuries: DB.EnumCase({ type: null }),
    Actions: DB.EnumCase({ type: null }),
    CombatRounds: DB.EnumCase({ type: null }),
@@ -1,5 +1,5 @@
 import * as DB from "tsondb/schema/dsl"
-import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js"
+import { ExpressionBasedParameterValue } from "./_ActivatableSkill.ts"
 import { SkillModificationLevelIdentifier } from "./_Identifier.js"
 import { ResponsiveTextOptional, ResponsiveTextReplace } from "./_ResponsiveText.js"
 import { NestedTranslationMap } from "./Locale.js"
@@ -42,8 +42,7 @@ const RangeValue = DB.Enum(import.meta.url, {
    Self: DB.EnumCase({ type: null }),
    Global: DB.EnumCase({ comment: "German: *dereumfassend*", type: null }),
    Touch: DB.EnumCase({ type: null }),
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedRange) }),
-    CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedRange) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedRange) }),
  }),
 })

@@ -89,21 +88,17 @@ export const FixedRange = DB.TypeAlias(import.meta.url, {
    }),
 })

-const CheckResultBasedRange = DB.TypeAlias(import.meta.url, {
-  name: "CheckResultBasedRange",
+export const ExpressionBasedRange = DB.TypeAlias(import.meta.url, {
+  name: "ExpressionBasedRange",
  type: () =>
    DB.Object({
      is_maximum: DB.Optional({
        comment: "If the range is the maximum range.",
        type: DB.Boolean(),
      }),
-      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),
+      value: DB.Required({
+        comment: "An expression that evaluates to the range.",
+        type: DB.IncludeIdentifier(ExpressionBasedParameterValue),
      }),
      unit: DB.Required({
        comment: "The duration unit.",
@@ -1,4 +1,5 @@
 import * as DB from "tsondb/schema/dsl"
+import { LanguageIdentifier } from "./_Identifier.js"

 export const AlternativeName = DB.TypeAlias(import.meta.url, {
  name: "AlternativeName",
@@ -12,5 +13,9 @@ export const AlternativeName = DB.TypeAlias(import.meta.url, {
        comment: "The region where this alternative name is used.",
        type: DB.String({ minLength: 1 }),
      }),
+      language: DB.Optional({
+        comment: "The language of that alternative name if any.",
+        type: LanguageIdentifier(),
+      }),
    }),
 })
@@ -24,13 +24,26 @@ export const CommonnessRatedAdvantageDisadvantage = DB.GenTypeAlias(import.meta.
      translations: NestedTranslationMap(
        DB.Optional,
        "CommonnessRatedAdvantageDisadvantage",
-        DB.Object({
-          options: DB.Required({
-            comment:
-              "The options the commonness rating applies to. This can be specified if plain options cannot exactly describe the options as written in the publication.",
-            type: DB.String({ minLength: 1 }),
-          }),
-        }),
+        DB.Object(
+          {
+            options: DB.Optional({
+              comment:
+                "The options the commonness rating applies to. This can be specified if plain options cannot exactly describe the options as written in the publication.",
+              type: DB.String({ minLength: 1 }),
+            }),
+            note: DB.Optional({
+              comment:
+                "A note, appended to the generated string in parenthesis. If options are specified as well, both will be in a single set of parentheses, with the note after the options.",
+              type: DB.String({ minLength: 1 }),
+            }),
+            full: DB.Optional({
+              comment:
+                "A text that replaces the entire entry. No other text is generated for display, however, providing levels or a selection of options will still be relevant for highlighting entries in the application. This should only be used if the text cannot be generated from other fields at all.",
+              type: DB.String({ minLength: 1 }),
+            }),
+          },
+          { minProperties: 1 },
+        ),
      ),
    }),
 })
@@ -3,6 +3,7 @@
 */

 import * as DB from "tsondb/schema/dsl"
+import { input } from "./_Activatable.ts"
 import { SkillWithEnhancementsIdentifier } from "./_IdentifierGroup.js"
 import { EnhancementPrerequisites } from "./_Prerequisite.js"
 import { NestedTranslationMap } from "./Locale.js"
@@ -32,12 +33,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),
@@ -63,6 +61,7 @@ export const Enhancement = DB.Entity(import.meta.url, {
              markdown: "block",
            }),
          }),
+          input,
          errata: DB.Optional({
            type: DB.IncludeIdentifier(Errata),
          }),
@@ -92,3 +91,36 @@ 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,
+        }),
+      }),
+    }),
+})
@@ -15,7 +15,7 @@ import { CloseCombatTechnique, RangedCombatTechnique } from "./CombatTechnique.j
 import { Condition } from "./Condition.js"
 import { Continent } from "./Continent.js"
 import { Culture } from "./Culture.js"
-import { DerivedCharacteristic } from "./DerivedCharacteristic.ts"
+import { DerivedCharacteristic } from "./DerivedCharacteristic.js"
 import { Disadvantage } from "./Disadvantage.js"
 import { Disease } from "./Disease.js"
 import { Element } from "./Element.js"
@@ -32,6 +32,8 @@ import { Container } from "./equipment/item/Container.js"
 import { Elixir } from "./equipment/item/Elixir.js"
 import { EquipmentOfBlessedOnes } from "./equipment/item/EquipmentOfBlessedOnes.js"
 import { GemOrPreciousStone } from "./equipment/item/GemOrPreciousStone.js"
+import { HerbalAid } from "./equipment/item/HerbalAid.js"
+import { HerbalPreservation } from "./equipment/item/HerbalPreservation.js"
 import { IlluminationLightSource } from "./equipment/item/IlluminationLightSource.js"
 import { IlluminationRefillOrSupply } from "./equipment/item/IlluminationRefillOrSupply.js"
 import { Jewelry } from "./equipment/item/Jewelry.js"
@@ -42,22 +44,26 @@ import { MagicalArtifact } from "./equipment/item/MagicalArtifact.js"
 import { MusicalInstrument } from "./equipment/item/MusicalInstrument.js"
 import { Newspaper } from "./equipment/item/Newspaper.js"
 import { OrienteeringAid } from "./equipment/item/OrienteeringAid.js"
+import { Plant } from "./equipment/item/Plant.js"
 import { Poison } from "./equipment/item/Poison.js"
 import { RopeOrChain } from "./equipment/item/RopeOrChain.js"
 import { Stationery } from "./equipment/item/Stationery.js"
 import { ArmorType } from "./equipment/item/sub/ArmorType.js"
+import { Biome } from "./equipment/item/sub/Biome.js"
+import { SubBiome } from "./equipment/item/sub/SubBiome.js"
 import { Reach } from "./equipment/item/sub/Reach.js"
+import { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js"
 import { ThievesTool } from "./equipment/item/ThievesTool.js"
 import { ToolOfTheTrade } from "./equipment/item/ToolOfTheTrade.js"
 import { TravelGearOrTool } from "./equipment/item/TravelGearOrTool.js"
 import { Vehicle } from "./equipment/item/Vehicle.js"
 import { Weapon } from "./equipment/item/Weapon.js"
 import { WeaponAccessory } from "./equipment/item/WeaponAccessory.js"
-import { WorkingSupernaturalCreature } from "./equipment/item/WorkingSupernaturalCreature.ts"
+import { WorkingSupernaturalCreature } from "./equipment/item/WorkingSupernaturalCreature.js"
 import { ExperienceLevel } from "./ExperienceLevel.js"
 import { EyeColor } from "./EyeColor.js"
 import { HairColor } from "./HairColor.js"
-import { Influence } from "./Influence.ts"
+import { Influence } from "./Influence.js"
 import { Curriculum, Guideline, LessonPackage } from "./Lessons.js"
 import { LiturgicalChant } from "./LiturgicalChant.js"
 import { AnimistPower } from "./magicalActions/AnimistPower.js"
@@ -142,12 +148,15 @@ import { CauldronEnchantment } from "./traditionArtifacts/CauldronEnchantment.js
 import { ChronicleEnchantment } from "./traditionArtifacts/ChronicleEnchantment.js"
 import { DaggerRitual } from "./traditionArtifacts/DaggerRitual.js"
 import { FoolsHatEnchantment } from "./traditionArtifacts/FoolsHatEnchantment.js"
+import { Hauerkettenzauber } from "./traditionArtifacts/Hauerkettenzauber.js"
 import { Haubenzauber } from "./traditionArtifacts/Haubenzauber.js"
 import { InstrumentEnchantment } from "./traditionArtifacts/InstrumentEnchantment.js"
+import { Keulenzauber } from "./traditionArtifacts/Keulenzauber.js"
 import { Krallenkettenzauber } from "./traditionArtifacts/Krallenkettenzauber.js"
 import { Kristallkugelzauber } from "./traditionArtifacts/Kristallkugelzauber.js"
 import { OrbEnchantment } from "./traditionArtifacts/OrbEnchantment.js"
 import { RingEnchantment } from "./traditionArtifacts/RingEnchantment.js"
+import { Schweinetrommelzauber } from "./traditionArtifacts/Schweinetrommelzauber.js"
 import { SickleRitual } from "./traditionArtifacts/SickleRitual.js"
 import { SpellSwordEnchantment } from "./traditionArtifacts/SpellSwordEnchantment.js"
 import { StaffEnchantment } from "./traditionArtifacts/StaffEnchantment.js"
@@ -187,6 +196,7 @@ export const AttributeIdentifier: () => R = () => R(Attribute)
 export const BandageOrRemedyIdentifier: () => R = () => R(BandageOrRemedy)
 export const BannzeichenIdentifier: () => R = () => R(Bannzeichen)
 export const BeutelzauberIdentifier: () => R = () => R(Beutelzauber)
+export const BiomeIdentifier: () => R = () => R(Biome)
 export const BlessedTraditionIdentifier: () => R = () => R(BlessedTradition)
 export const BlessingIdentifier: () => R = () => R(Blessing)
 export const BookIdentifier: () => R = () => R(Book)
@@ -238,6 +248,9 @@ export const GoblinRitualIdentifier: () => R = () => R(GoblinRitual)
 export const GuidelineIdentifier: () => R = () => R(Guideline)
 export const HairColorIdentifier: () => R = () => R(HairColor)
 export const HaubenzauberIdentifier: () => R = () => R(Haubenzauber)
+export const HauerkettenZauberIdentifier: () => R = () => R(Hauerkettenzauber)
+export const HerbalAidIdentifier: () => R = () => R(HerbalAid)
+export const HerbalPreservationIdentifier: () => R = () => R(HerbalPreservation)
 export const IlluminationLightSourceIdentifier: () => R = () => R(IlluminationLightSource)
 export const IlluminationRefillOrSupplyIdentifier: () => R = () => R(IlluminationRefillOrSupply)
 export const InfluenceIdentifier: () => R = () => R(Influence)
@@ -245,6 +258,7 @@ export const InstrumentEnchantmentIdentifier: () => R = () => R(InstrumentEnchan
 export const JesterTrickIdentifier: () => R = () => R(JesterTrick)
 export const JewelryIdentifier: () => R = () => R(Jewelry)
 export const KarmaSpecialAbilityIdentifier: () => R = () => R(KarmaSpecialAbility)
+export const KeulenzauberIdentifier: () => R = () => R(Keulenzauber)
 export const KrallenkettenzauberIdentifier: () => R = () => R(Krallenkettenzauber)
 export const KristallkugelzauberIdentifier: () => R = () => R(Kristallkugelzauber)
 export const LaboratoryIdentifier: () => R = () => R(Laboratory)
@@ -278,6 +292,7 @@ export const PactTypeIdentifier: () => R = () => R(PactType)
 export const PatronCategoryIdentifier: () => R = () => R(PatronCategory)
 export const PatronIdentifier: () => R = () => R(Patron)
 export const PersonalityTraitIdentifier: () => R = () => R(PersonalityTrait)
+export const PlantIdentifier: () => R = () => R(Plant)
 export const PlayerTypeIdentifier: () => R = () => R(PlayerType)
 export const PoisonIdentifier: () => R = () => R(Poison)
 export const ProfessionIdentifier: () => R = () => R(Profession)
@@ -291,9 +306,11 @@ export const RaceIdentifier: () => R = () => R(Race)
 export const RaceVariantIdentifier: () => R = () => R(RaceVariant)
 export const RangedCombatTechniqueIdentifier: () => R = () => R(RangedCombatTechnique)
 export const ReachIdentifier: () => R = () => R(Reach)
+export const BotanicRegionIdentifier: () => R = () => R(BotanicRegion)
 export const RingEnchantmentIdentifier: () => R = () => R(RingEnchantment)
 export const RitualIdentifier: () => R = () => R(Ritual)
 export const RopeOrChainIdentifier: () => R = () => R(RopeOrChain)
+export const SchweinetrommelzauberIdentifier: () => R = () => R(Schweinetrommelzauber)
 export const ScriptIdentifier: () => R = () => R(Script)
 export const SermonIdentifier: () => R = () => R(Sermon)
 export const SexPracticeIdentifier: () => R = () => R(SexPractice)
@@ -313,6 +330,7 @@ export const SpellSwordEnchantmentIdentifier: () => R = () => R(SpellSwordEnchan
 export const StaffEnchantmentIdentifier: () => R = () => R(StaffEnchantment)
 export const StateIdentifier: () => R = () => R(State)
 export const StationeryIdentifier: () => R = () => R(Stationery)
+export const SubBiomeIdentifier: () => R = () => R(SubBiome)
 export const SubjectIdentifier: () => R = () => R(Subject)
 export const TargetCategoryIdentifier: () => R = () => R(TargetCategory)
 export const ThievesToolIdentifier: () => R = () => R(ThievesTool)
@@ -1,3 +1,4 @@
+import { sortObjectKeys } from "@elyukai/utils/object"
 import * as DB from "tsondb/schema/dsl"
 import {
  AdvancedCombatSpecialAbilityIdentifier,
@@ -62,12 +63,14 @@ import {
  GeodeRitualIdentifier,
  GoblinRitualIdentifier,
  HaubenzauberIdentifier,
+  HauerkettenZauberIdentifier,
  IlluminationLightSourceIdentifier,
  IlluminationRefillOrSupplyIdentifier,
  InstrumentEnchantmentIdentifier,
  JesterTrickIdentifier,
  JewelryIdentifier,
  KarmaSpecialAbilityIdentifier,
+  KeulenzauberIdentifier,
  KrallenkettenzauberIdentifier,
  KristallkugelzauberIdentifier,
  LaboratoryIdentifier,
@@ -100,6 +103,7 @@ import {
  RingEnchantmentIdentifier,
  RitualIdentifier,
  RopeOrChainIdentifier,
+  SchweinetrommelzauberIdentifier,
  ScriptIdentifier,
  SermonIdentifier,
  SexPracticeIdentifier,
@@ -164,65 +168,80 @@ export const NewSkillApplicationOrUseParentIdentifier = DB.Enum(import.meta.url,
  }),
 })

-export const SpecialAbilityIdentifier = DB.Enum(import.meta.url, {
-  name: "SpecialAbilityIdentifier",
+export const TraditionArtifactEnchantmentIdentifier = DB.Enum(import.meta.url, {
+  name: "TraditionArtifactEnchantmentIdentifier",
  values: () => ({
-    AdvancedCombatSpecialAbility: DB.EnumCase({ type: AdvancedCombatSpecialAbilityIdentifier() }),
-    AdvancedKarmaSpecialAbility: DB.EnumCase({ type: AdvancedKarmaSpecialAbilityIdentifier() }),
-    AdvancedMagicalSpecialAbility: DB.EnumCase({ type: AdvancedMagicalSpecialAbilityIdentifier() }),
-    AdvancedSkillSpecialAbility: DB.EnumCase({ type: AdvancedSkillSpecialAbilityIdentifier() }),
-    AncestorGlyph: DB.EnumCase({ type: AncestorGlyphIdentifier() }),
    ArcaneOrbEnchantment: DB.EnumCase({ type: ArcaneOrbEnchantmentIdentifier() }),
    AttireEnchantment: DB.EnumCase({ type: AttireEnchantmentIdentifier() }),
    Beutelzauber: DB.EnumCase({ type: BeutelzauberIdentifier() }),
-    BlessedTradition: DB.EnumCase({ type: BlessedTraditionIdentifier() }),
    BowlEnchantment: DB.EnumCase({ type: BowlEnchantmentIdentifier() }),
-    BrawlingSpecialAbility: DB.EnumCase({ type: BrawlingSpecialAbilityIdentifier() }),
    CauldronEnchantment: DB.EnumCase({ type: CauldronEnchantmentIdentifier() }),
-    CeremonialItemSpecialAbility: DB.EnumCase({ type: CeremonialItemSpecialAbilityIdentifier() }),
-    ChronicleEnchantment: DB.EnumCase({ type: ChronicleEnchantmentIdentifier() }),
-    CombatSpecialAbility: DB.EnumCase({ type: CombatSpecialAbilityIdentifier() }),
-    CombatStyleSpecialAbility: DB.EnumCase({ type: CombatStyleSpecialAbilityIdentifier() }),
-    CommandSpecialAbility: DB.EnumCase({ type: CommandSpecialAbilityIdentifier() }),
    DaggerRitual: DB.EnumCase({ type: DaggerRitualIdentifier() }),
-    FamiliarSpecialAbility: DB.EnumCase({ type: FamiliarSpecialAbilityIdentifier() }),
-    FatePointSexSpecialAbility: DB.EnumCase({ type: FatePointSexSpecialAbilityIdentifier() }),
-    FatePointSpecialAbility: DB.EnumCase({ type: FatePointSpecialAbilityIdentifier() }),
    FoolsHatEnchantment: DB.EnumCase({ type: FoolsHatEnchantmentIdentifier() }),
-    GeneralSpecialAbility: DB.EnumCase({ type: GeneralSpecialAbilityIdentifier() }),
    Haubenzauber: DB.EnumCase({ type: HaubenzauberIdentifier() }),
+    Hauerkettenzauber: DB.EnumCase({ type: HauerkettenZauberIdentifier() }),
    InstrumentEnchantment: DB.EnumCase({ type: InstrumentEnchantmentIdentifier() }),
-    KarmaSpecialAbility: DB.EnumCase({ type: KarmaSpecialAbilityIdentifier() }),
+    Keulenzauber: DB.EnumCase({ type: KeulenzauberIdentifier() }),
    Krallenkettenzauber: DB.EnumCase({ type: KrallenkettenzauberIdentifier() }),
    Kristallkugelzauber: DB.EnumCase({ type: KristallkugelzauberIdentifier() }),
-    LiturgicalStyleSpecialAbility: DB.EnumCase({ type: LiturgicalStyleSpecialAbilityIdentifier() }),
-    LycantropicGift: DB.EnumCase({ type: LycantropicGiftIdentifier() }),
-    MagicalSign: DB.EnumCase({ type: MagicalSignIdentifier() }),
-    MagicalSpecialAbility: DB.EnumCase({ type: MagicalSpecialAbilityIdentifier() }),
-    MagicalTradition: DB.EnumCase({ type: MagicalTraditionIdentifier() }),
-    MagicStyleSpecialAbility: DB.EnumCase({ type: MagicStyleSpecialAbilityIdentifier() }),
    OrbEnchantment: DB.EnumCase({ type: OrbEnchantmentIdentifier() }),
-    PactGift: DB.EnumCase({ type: PactGiftIdentifier() }),
-    ProtectiveWardingCircleSpecialAbility: DB.EnumCase({
-      type: ProtectiveWardingCircleSpecialAbilityIdentifier(),
-    }),
    RingEnchantment: DB.EnumCase({ type: RingEnchantmentIdentifier() }),
-    Sermon: DB.EnumCase({ type: SermonIdentifier() }),
-    SexSpecialAbility: DB.EnumCase({ type: SexSpecialAbilityIdentifier() }),
+    Schweinetrommelzauber: DB.EnumCase({ type: SchweinetrommelzauberIdentifier() }),
    SickleRitual: DB.EnumCase({ type: SickleRitualIdentifier() }),
-    SikaryanDrainSpecialAbility: DB.EnumCase({ type: SikaryanDrainSpecialAbilityIdentifier() }),
-    SkillStyleSpecialAbility: DB.EnumCase({ type: SkillStyleSpecialAbilityIdentifier() }),
    SpellSwordEnchantment: DB.EnumCase({ type: SpellSwordEnchantmentIdentifier() }),
    StaffEnchantment: DB.EnumCase({ type: StaffEnchantmentIdentifier() }),
    ToyEnchantment: DB.EnumCase({ type: ToyEnchantmentIdentifier() }),
    Trinkhornzauber: DB.EnumCase({ type: TrinkhornzauberIdentifier() }),
-    VampiricGift: DB.EnumCase({ type: VampiricGiftIdentifier() }),
-    Vision: DB.EnumCase({ type: VisionIdentifier() }),
    WandEnchantment: DB.EnumCase({ type: WandEnchantmentIdentifier() }),
    WeaponEnchantment: DB.EnumCase({ type: WeaponEnchantmentIdentifier() }),
  }),
 })

+export const SpecialAbilityIdentifier = DB.Enum(import.meta.url, {
+  name: "SpecialAbilityIdentifier",
+  values: () =>
+    sortObjectKeys({
+      AdvancedCombatSpecialAbility: DB.EnumCase({ type: AdvancedCombatSpecialAbilityIdentifier() }),
+      AdvancedKarmaSpecialAbility: DB.EnumCase({ type: AdvancedKarmaSpecialAbilityIdentifier() }),
+      AdvancedMagicalSpecialAbility: DB.EnumCase({
+        type: AdvancedMagicalSpecialAbilityIdentifier(),
+      }),
+      AdvancedSkillSpecialAbility: DB.EnumCase({ type: AdvancedSkillSpecialAbilityIdentifier() }),
+      AncestorGlyph: DB.EnumCase({ type: AncestorGlyphIdentifier() }),
+      BlessedTradition: DB.EnumCase({ type: BlessedTraditionIdentifier() }),
+      BrawlingSpecialAbility: DB.EnumCase({ type: BrawlingSpecialAbilityIdentifier() }),
+      CeremonialItemSpecialAbility: DB.EnumCase({ type: CeremonialItemSpecialAbilityIdentifier() }),
+      ChronicleEnchantment: DB.EnumCase({ type: ChronicleEnchantmentIdentifier() }),
+      CombatSpecialAbility: DB.EnumCase({ type: CombatSpecialAbilityIdentifier() }),
+      CombatStyleSpecialAbility: DB.EnumCase({ type: CombatStyleSpecialAbilityIdentifier() }),
+      CommandSpecialAbility: DB.EnumCase({ type: CommandSpecialAbilityIdentifier() }),
+      FamiliarSpecialAbility: DB.EnumCase({ type: FamiliarSpecialAbilityIdentifier() }),
+      FatePointSexSpecialAbility: DB.EnumCase({ type: FatePointSexSpecialAbilityIdentifier() }),
+      FatePointSpecialAbility: DB.EnumCase({ type: FatePointSpecialAbilityIdentifier() }),
+      GeneralSpecialAbility: DB.EnumCase({ type: GeneralSpecialAbilityIdentifier() }),
+      KarmaSpecialAbility: DB.EnumCase({ type: KarmaSpecialAbilityIdentifier() }),
+      LiturgicalStyleSpecialAbility: DB.EnumCase({
+        type: LiturgicalStyleSpecialAbilityIdentifier(),
+      }),
+      LycantropicGift: DB.EnumCase({ type: LycantropicGiftIdentifier() }),
+      MagicalSign: DB.EnumCase({ type: MagicalSignIdentifier() }),
+      MagicalSpecialAbility: DB.EnumCase({ type: MagicalSpecialAbilityIdentifier() }),
+      MagicalTradition: DB.EnumCase({ type: MagicalTraditionIdentifier() }),
+      MagicStyleSpecialAbility: DB.EnumCase({ type: MagicStyleSpecialAbilityIdentifier() }),
+      PactGift: DB.EnumCase({ type: PactGiftIdentifier() }),
+      ProtectiveWardingCircleSpecialAbility: DB.EnumCase({
+        type: ProtectiveWardingCircleSpecialAbilityIdentifier(),
+      }),
+      Sermon: DB.EnumCase({ type: SermonIdentifier() }),
+      SexSpecialAbility: DB.EnumCase({ type: SexSpecialAbilityIdentifier() }),
+      SikaryanDrainSpecialAbility: DB.EnumCase({ type: SikaryanDrainSpecialAbilityIdentifier() }),
+      SkillStyleSpecialAbility: DB.EnumCase({ type: SkillStyleSpecialAbilityIdentifier() }),
+      VampiricGift: DB.EnumCase({ type: VampiricGiftIdentifier() }),
+      Vision: DB.EnumCase({ type: VisionIdentifier() }),
+      ...TraditionArtifactEnchantmentIdentifier.type.value.values,
+    }),
+})
+
 export const CombatRelatedSpecialAbilityIdentifier = DB.Enum(import.meta.url, {
  name: "CombatRelatedSpecialAbilityIdentifier",
  values: () => ({
@@ -407,6 +426,8 @@ export const RequirableSelectOptionIdentifier = DB.Enum(import.meta.url, {
    RangedCombatTechnique: DB.EnumCase({ type: RangedCombatTechniqueIdentifier() }),
    Property: DB.EnumCase({ type: PropertyIdentifier() }),
    Aspect: DB.EnumCase({ type: AspectIdentifier() }),
+    Disease: DB.EnumCase({ type: DiseaseIdentifier() }),
+    Poison: DB.EnumCase({ type: PoisonIdentifier() }),
    Language: DB.EnumCase({ type: LanguageIdentifier() }),
    AnimalShape: DB.EnumCase({ type: AnimalShapeIdentifier() }),
    LiturgicalChant: DB.EnumCase({ type: LiturgicalChantIdentifier() }),
@@ -1,3 +1,21 @@
+/**
+ * Originally, this type was created to represent the text of a spell, which can
+ * be displayed in full on the spell card, but also in a compressed version on
+ * the character sheet. However, it can be used for any text that has a similar
+ * requirement.
+ *
+ * The `ResponsiveTextReplace` type is a special case where the full and
+ * compressed versions are not standalone texts, but rather templates that
+ * include a placeholder (`$1`) for a generated string. The generated string is
+ * expected to adapt to different size contexts as well.
+ *
+ * The `ResponsiveTextOptional` type allows for the possibility that a
+ * compressed version may not be provided. In such cases, the full text should
+ * be used in all contexts, and the absence of a compressed version indicates
+ * that no special formatting is needed for smaller areas.
+ * @module
+ */
+
 import * as DB from "tsondb/schema/dsl"

 export const ResponsiveText = DB.TypeAlias(import.meta.url, {
@@ -0,0 +1,67 @@
+import * as DB from "tsondb/schema/dsl"
+import { src } from "../../source/_PublicationRef.js"
+import { NestedTranslationMap } from "../../Locale.js"
+import { WeaponIdentifier, ArmorIdentifier } from "../../_Identifier.js"
+import { EffectType, RecipeTradeSecret } from "./_Herbary.js"
+
+export const HerbalAid = DB.Entity(import.meta.url, {
+  name: "HerbalAid",
+  namePlural: "HerbalAids",
+  type: () =>
+    DB.Object({
+      types: DB.Required({
+        comment: "The plant types this aid belongs to.",
+        type: DB.Array(DB.IncludeIdentifier(EffectType), { minItems: 1, uniqueItems: true }),
+      }),
+      crafting_difficulty: DB.Required({
+        comment: "The difficulty for this aid to craft.",
+        type: DB.Integer(),
+      }),
+      trade_secret: DB.Optional({
+        comment: "AP value and prerequisites of the herbal aid�s trade secret.",
+        type: DB.IncludeIdentifier(RecipeTradeSecret),
+      }),
+      combatUse: DB.Optional({
+        comment: "The armor or weapon this herbal aid represents.",
+        type: DB.IncludeIdentifier(HerbalAidCombatUse),
+      }),
+      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({
+            comment: "The herbal aid's description.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+          }),
+          ingredients: DB.Required({
+            comment: "The ingredients used to craft this herbal aid.",
+            type: DB.Array(DB.String({ minLength: 1, markdown: "inline" }), { minItems: 1 }),
+          }),
+          typical_tools: DB.Optional({
+            comment: "The typical tools used to craft this.",
+            type: DB.Array(DB.String({ minLength: 1, markdown: "inline" }), { minItems: 1 }),
+          }),
+        }),
+      ),
+    }),
+  instanceDisplayName: {},
+  uniqueConstraints: [
+    {
+      entityMapKeyPath: "translations",
+      keyPathInEntityMap: "name",
+    },
+  ],
+})
+
+const HerbalAidCombatUse = DB.Enum(import.meta.url, {
+  name: "HerbalAidCombatUse",
+  values: () => ({
+    Weapon: DB.EnumCase({ type: WeaponIdentifier() }),
+    Armor: DB.EnumCase({ type: ArmorIdentifier() }),
+  }),
+})
@@ -0,0 +1,93 @@
+import * as DB from "tsondb/schema/dsl"
+import { NestedTranslationMap } from "../../Locale.js"
+import { DurationUnit } from "../../_ActivatableSkillDuration.js"
+import { ResponsiveTextReplace } from "../../_ResponsiveText.js"
+import { Dice } from "../../_Dice.js"
+import { MathOperation } from "../../_MathExpression.js"
+import { EffectType } from "./_Herbary.js"
+import { src } from "../../source/_PublicationRef.js"
+
+export const HerbalPreservation = DB.Entity(import.meta.url, {
+  name: "HerbalPreservation",
+  namePlural: "HerbalPreservations",
+  type: () =>
+    DB.Object({
+      types: DB.Required({
+        comment: "The types of this preservation.",
+        type: DB.Array(DB.IncludeIdentifier(EffectType), { minItems: 1, uniqueItems: true }),
+      }),
+      longevity: DB.Required({
+        comment: "How long this preservation lasts.",
+        type: DB.IncludeIdentifier(HerbalPreservationLongevity),
+      }),
+      src,
+      translations: NestedTranslationMap(
+        DB.Required,
+        "HerbalPreservation",
+        DB.Object({
+          name: DB.Required({
+            comment: "The herbal preservation's name.",
+            type: DB.String({ minLength: 1 }),
+          }),
+          preparation: DB.Required({
+            comment: "How to prepare this preservation.",
+            type: DB.String({ minLength: 1, markdown: "inline" }),
+          }),
+          alternative_effect: DB.Required({
+            comment: "The herbal preservation's alternative effect.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+          }),
+        }),
+      ),
+    }),
+  instanceDisplayName: {},
+  uniqueConstraints: [
+    {
+      entityMapKeyPath: "translations",
+      keyPathInEntityMap: "name",
+    },
+  ],
+})
+
+export const HerbalPreservationLongevity = DB.TypeAlias(import.meta.url, {
+  name: "HerbalPreservationLongevity",
+  type: () =>
+    DB.Object({
+      value: DB.Required({
+        comment: "An expression that evaluates to the duration.",
+        type: DB.IncludeIdentifier(HerbalPreservationLongevityExpression),
+      }),
+      unit: DB.Required({
+        comment: "The duration unit.",
+        type: DB.IncludeIdentifier(DurationUnit),
+      }),
+      translations: NestedTranslationMap(
+        DB.Optional,
+        "HerbalPreservationLongevity",
+        DB.Object({
+          replacement: DB.Required({
+            comment: "A replacement string.",
+            type: DB.IncludeIdentifier(ResponsiveTextReplace),
+          }),
+        }),
+      ),
+    }),
+})
+
+export const HerbalPreservationLongevityExpression = DB.TypeAlias(import.meta.url, {
+  name: "HerbalPreservationLongevityExpression",
+  type: () =>
+    DB.GenIncludeIdentifier(MathOperation, [
+      DB.IncludeIdentifier(HerbalPreservationLongevityValue),
+    ]),
+})
+
+export const HerbalPreservationLongevityValue = DB.Enum(import.meta.url, {
+  name: "HerbalPreservationLongevityValue",
+  values: () => ({
+    Constant: DB.EnumCase({ type: DB.Integer({ minimum: 1 }) }),
+    Dice: DB.EnumCase({
+      type: DB.IncludeIdentifier(Dice),
+    }),
+  }),
+})
@@ -0,0 +1,361 @@
+import * as DB from "tsondb/schema/dsl"
+import { src } from "../../source/_PublicationRef.js"
+import { NestedTranslationMap } from "../../Locale.js"
+import { AlternativeName } from "../../_AlternativeNames.js"
+import {
+  BiomeIdentifier,
+  SubBiomeIdentifier,
+  BotanicRegionIdentifier,
+  HerbalAidIdentifier,
+  HerbalPreservationIdentifier,
+  ElixirIdentifier,
+  PoisonIdentifier,
+} from "../../_Identifier.js"
+import { ResponsiveTextOptional, ResponsiveTextReplace } from "../../_ResponsiveText.js"
+import { EffectType, PlantRarity } from "./_Herbary.js"
+
+export const Plant = DB.Entity(import.meta.url, {
+  name: "Plant",
+  namePlural: "Plants",
+  type: () =>
+    DB.Object({
+      types: DB.Required({
+        comment: "The plant types of this plant.",
+        type: DB.Array(DB.IncludeIdentifier(EffectType), { minItems: 1, uniqueItems: true }),
+      }),
+      occurences: DB.Required({
+        comment: "The biomes this plant occurs in and its rarity in those biomes.",
+        type: DB.IncludeIdentifier(PlantOccurences),
+      }),
+      search_difficulty: DB.Required({
+        comment: "The search difficulty for this plant.",
+        type: DB.IncludeIdentifier(PlantDifficulty),
+      }),
+      identification_difficulty: DB.Required({
+        comment: "The identification difficulty for this plant.",
+        type: DB.IncludeIdentifier(PlantDifficulty),
+      }),
+      applications: DB.Required({
+        comment: "The applications of this plant per quality level.",
+        type: DB.IncludeIdentifier(PlantApplications),
+      }),
+      touch: DB.Optional({
+        comment: "The plant's touch effect.",
+        type: DB.IncludeIdentifier(PlantEffect),
+      }),
+      inhalation: DB.Optional({
+        comment: "The plant's inhalation effect.",
+        type: DB.IncludeIdentifier(PlantEffect),
+      }),
+      ingestion: DB.Optional({
+        comment: "The plant's ingestion effect.",
+        type: DB.IncludeIdentifier(PlantEffect),
+      }),
+      price: DB.Required({
+        comment: "The price of the plant.",
+        type: DB.IncludeIdentifier(PlantPrice),
+      }),
+      recipes: DB.Optional({
+        comment: "The herbal aids and elixirs that can be crafted with this plant.",
+        type: DB.Array(DB.IncludeIdentifier(PlantRecipe), { minItems: 1 }),
+      }),
+      longevity: DB.Optional({
+        comment: "The longevity of the plant.",
+        type: DB.IncludeIdentifier(PlantLongevity),
+      }),
+      src,
+      translations: NestedTranslationMap(
+        DB.Required,
+        "Plant",
+        DB.Object({
+          name: DB.Required({
+            comment: "The plant's name.",
+            type: DB.String({ minLength: 1 }),
+          }),
+          alternative_names: DB.Optional({
+            comment: "A list of alternative names.",
+            type: DB.Array(DB.IncludeIdentifier(AlternativeName), { minItems: 1 }),
+          }),
+          remedies_and_traditions: DB.Required({
+            comment: "How this plant is used as a household remedy and in folk traditions.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+          }),
+          knowledge: DB.Required({
+            comment:
+              "What one knows about this plant for each quality level. The first element represents QL 1, the second element QL 2, and so on.",
+            type: DB.Array(DB.String({ minLength: 1, markdown: "block" }), {
+              minItems: 3,
+              maxItems: 6,
+            }),
+          }),
+        }),
+      ),
+    }),
+  instanceDisplayName: {},
+  uniqueConstraints: [
+    {
+      entityMapKeyPath: "translations",
+      keyPathInEntityMap: "name",
+    },
+  ],
+})
+
+const PlantOccurences = DB.TypeAlias(import.meta.url, {
+  name: "PlantOccurences",
+  type: () =>
+    DB.Object(
+      {
+        items: DB.Optional({
+          comment: "The biomes this plant occurs in and its rarity in those biomes.",
+          type: DB.Array(DB.IncludeIdentifier(PlantOccurrence), { minItems: 1 }),
+        }),
+        translation: NestedTranslationMap(
+          DB.Optional,
+          "PlantOccurrences",
+          DB.Object({
+            note: DB.Required({
+              comment: "A note to all occurences of this plant",
+              type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+          }),
+        ),
+      },
+      {
+        minProperties: 1,
+      },
+    ),
+})
+
+const PlantOccurrence = DB.TypeAlias(import.meta.url, {
+  name: "PlantOccurrence",
+  type: () =>
+    DB.Object({
+      regions: DB.Required({
+        comment: "Where this plant occurs in.",
+        type: DB.IncludeIdentifier(PlantOccurrenceTier),
+      }),
+      rarity: DB.Required({
+        comment: "The rarity of this plant in the biome.",
+        type: DB.IncludeIdentifier(PlantRarity),
+      }),
+      translation: NestedTranslationMap(
+        DB.Optional,
+        "PlantOccurrence",
+        DB.Object({
+          note: DB.Required({
+            comment: "A note added to this occurrence",
+            type: DB.String({ minLength: 1, markdown: "inline" }),
+          }),
+        }),
+      ),
+    }),
+})
+
+const PlantOccurrenceTier = DB.Enum(import.meta.url, {
+  name: "PlantOccurrenceTier",
+  values: () => ({
+    Biomes: DB.EnumCase({
+      type: DB.Array(BiomeIdentifier(), { minItems: 1 }),
+    }),
+    SubBiomes: DB.EnumCase({
+      type: DB.Array(SubBiomeIdentifier(), { minItems: 1 }),
+    }),
+    BotanicRegions: DB.EnumCase({
+      type: DB.Array(BotanicRegionIdentifier(), { minItems: 1 }),
+    }),
+  }),
+})
+
+const PlantDifficulty = DB.Enum(import.meta.url, {
+  name: "PlantDifficulty",
+  values: () => ({
+    Constant: DB.EnumCase({ type: DB.Integer() }),
+    Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefinitePlantDescription) }),
+  }),
+})
+
+const IndefinitePlantDescription = DB.TypeAlias(import.meta.url, {
+  name: "IndefinitePlantDescription",
+  type: () =>
+    DB.Object({
+      translations: NestedTranslationMap(
+        DB.Required,
+        "IndefinitePlantDescription",
+        DB.Object({
+          description: DB.Required({
+            comment: "A description of whatever is indefinite of this plant.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+          }),
+        }),
+      ),
+    }),
+})
+
+const PlantApplications = DB.Enum(import.meta.url, {
+  name: "PlantApplications",
+  values: () => ({
+    Constant: DB.EnumCase({ type: DB.Array(DB.Integer(), { minItems: 6, maxItems: 6 }) }),
+    Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefinitePlantDescription) }),
+  }),
+})
+
+const PlantEffect = DB.TypeAlias(import.meta.url, {
+  name: "PlantEffect",
+  type: () =>
+    DB.Object({
+      types: DB.Optional({
+        comment: "The effect type of this plant effect.",
+        type: DB.Array(DB.IncludeIdentifier(EffectType), { minItems: 1, uniqueItems: true }),
+      }),
+      translations: NestedTranslationMap(
+        DB.Required,
+        "PlantEffectTranslation",
+        DB.Object({
+          description: DB.Required({
+            comment: "The effect of the plant.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+          }),
+        }),
+      ),
+    }),
+})
+
+const PlantPrice = DB.Enum(import.meta.url, {
+  name: "PlantPrice",
+  values: () => ({
+    Constant: DB.EnumCase({
+      type: DB.Object({
+        value: DB.Required({
+          comment: "The value of the plant in silver coins.",
+          type: DB.Float({ minimum: 0 }),
+        }),
+        cost: DB.Required({
+          comment: "The cost of the plant in silver coins.",
+          type: DB.Float({ minimum: 0 }),
+        }),
+      }),
+    }),
+    Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefinitePlantPrice) }),
+  }),
+})
+
+const IndefinitePlantPrice = DB.TypeAlias(import.meta.url, {
+  name: "IndefinitePlantPrice",
+  type: () =>
+    DB.Object({
+      translations: NestedTranslationMap(
+        DB.Required,
+        "IndefinitePlantPrice",
+        DB.Object({
+          description: DB.Required({
+            comment: "A description of the price.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+          }),
+        }),
+      ),
+    }),
+})
+
+const PlantRecipe = DB.Enum(import.meta.url, {
+  name: "PlantRecipe",
+  values: () => ({
+    HerbalAid: DB.EnumCase({ type: DB.IncludeIdentifier(HerbalAidRecipe) }),
+    Elixir: DB.EnumCase({ type: DB.IncludeIdentifier(ElixirRecipe) }),
+    Poison: DB.EnumCase({ type: DB.IncludeIdentifier(PoisonRecipe) }),
+    Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteRecipe) }),
+  }),
+})
+
+const PlantProductTranslation = DB.Object(
+  {
+    note: DB.Optional({
+      comment:
+        "A note, appended to the generated string in parenthesis. If the generated is modified using `replacement`, the note is appended to the modifier string.",
+      type: DB.IncludeIdentifier(ResponsiveTextOptional),
+    }),
+    replacement: DB.Optional({
+      comment:
+        "A replacement string. If `note` is provided, it is appended to the replaced string.",
+      type: DB.IncludeIdentifier(ResponsiveTextReplace),
+    }),
+  },
+  { minProperties: 1 },
+)
+
+const HerbalAidRecipe = DB.TypeAlias(import.meta.url, {
+  name: "HerbalAidRecipe",
+  type: () =>
+    DB.Object({
+      herbal_aid: DB.Required({
+        comment: "The herbal aid this recipe results in.",
+        type: HerbalAidIdentifier(),
+      }),
+      translation: NestedTranslationMap(DB.Optional, "HerbalAidRecipe", PlantProductTranslation),
+    }),
+})
+
+const ElixirRecipe = DB.TypeAlias(import.meta.url, {
+  name: "ElixirRecipe",
+  type: () =>
+    DB.Object({
+      elixir: DB.Required({
+        comment: "The elixir this recipe results in.",
+        type: ElixirIdentifier(),
+      }),
+      translation: NestedTranslationMap(DB.Optional, "ElixirRecipe", PlantProductTranslation),
+    }),
+})
+
+const PoisonRecipe = DB.TypeAlias(import.meta.url, {
+  name: "PoisonRecipe",
+  type: () =>
+    DB.Object({
+      poison: DB.Required({
+        comment: "The poison this recipe results in.",
+        type: PoisonIdentifier(),
+      }),
+      translation: NestedTranslationMap(DB.Optional, "PoisonRecipe", PlantProductTranslation),
+    }),
+})
+
+const IndefiniteRecipe = DB.TypeAlias(import.meta.url, {
+  name: "IndefiniteRecipe",
+  type: () =>
+    DB.Object({
+      translations: NestedTranslationMap(
+        DB.Required,
+        "IndefiniteRecipe",
+        DB.Object({
+          description: DB.Required({
+            comment: "A description of the recipe.",
+            type: DB.String({ minLength: 1, markdown: "inline" }),
+          }),
+        }),
+      ),
+    }),
+})
+
+const PlantLongevity = DB.TypeAlias(import.meta.url, {
+  name: "PlantLongevity",
+  type: () =>
+    DB.Object({
+      preservations: DB.Optional({
+        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({
+            comment: "The longevity of the raw plant",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+          }),
+          preserved: DB.Optional({
+            comment: "The longevity of the preserved plant",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+          }),
+        }),
+      ),
+    }),
+})
@@ -19,6 +19,18 @@ export const EffectType = DB.Enum(import.meta.url, {
  }),
 })

+export const PlantRarity = DB.Enum(import.meta.url, {
+  name: "PlantRarity",
+  comment: "The rarity of a plant in a biome.",
+  values: () => ({
+    Common: DB.EnumCase({ type: null }),
+    Occasional: DB.EnumCase({ type: null }),
+    RatherRare: DB.EnumCase({ type: null }),
+    Rare: DB.EnumCase({ type: null }),
+    VeryRare: DB.EnumCase({ type: null }),
+  }),
+})
+
 export const LaboratoryLevel = DB.Enum(import.meta.url, {
  name: "LaboratoryLevel",
  values: () => ({
@@ -0,0 +1,31 @@
+import * as DB from "tsondb/schema/dsl"
+import { NestedTranslationMap } from "../../../Locale.js"
+import { SubBiome } from "./SubBiome.js"
+
+export const Biome = DB.Entity(import.meta.url, {
+  name: "Biome",
+  namePlural: "Biome",
+  type: () =>
+    DB.Object({
+      translations: NestedTranslationMap(
+        DB.Required,
+        "Biome",
+        DB.Object({
+          name: DB.Required({
+            comment: "The biome's name.",
+            type: DB.String({ minLength: 1 }),
+          }),
+        }),
+      ),
+      sub_biomes: DB.Required({
+        type: DB.ChildEntitiesType(SubBiome),
+      }),
+    }),
+  instanceDisplayName: {},
+  uniqueConstraints: [
+    {
+      entityMapKeyPath: "translations",
+      keyPathInEntityMap: "name",
+    },
+  ],
+})
@@ -0,0 +1,38 @@
+import * as DB from "tsondb/schema/dsl"
+import { NestedTranslationMap } from "../../../Locale.js"
+import { SubBiomeIdentifier } from "../../../_Identifier.js"
+
+export const BotanicRegion = DB.Entity(import.meta.url, {
+  name: "BotanicRegion",
+  namePlural: "BotanicRegions",
+  type: () =>
+    DB.Object({
+      parent: DB.Required({
+        comment: "The subbiome this region belongs to.",
+        type: SubBiomeIdentifier(),
+      }),
+      translations: NestedTranslationMap(
+        DB.Required,
+        "BotanicRegion",
+        DB.Object({
+          name: DB.Required({
+            comment: "The region's name.",
+            type: DB.String({ minLength: 1 }),
+          }),
+        }),
+      ),
+    }),
+  parentReferenceKey: "parent",
+  instanceDisplayName: {},
+  uniqueConstraints: [
+    [
+      {
+        entityMapKeyPath: "translations",
+        keyPathInEntityMap: "name",
+      },
+      {
+        keyPath: "parent",
+      },
+    ],
+  ],
+})
@@ -0,0 +1,37 @@
+import * as DB from "tsondb/schema/dsl"
+import { NestedTranslationMap } from "../../../Locale.js"
+import { BiomeIdentifier } from "../../../_Identifier.js"
+import { BotanicRegion } from "./BotanicRegion.js"
+
+export const SubBiome = DB.Entity(import.meta.url, {
+  name: "SubBiome",
+  namePlural: "SubBiomes",
+  type: () =>
+    DB.Object({
+      parent: DB.Required({
+        comment: "The biome this sub-biome belongs to.",
+        type: BiomeIdentifier(),
+      }),
+      translations: NestedTranslationMap(
+        DB.Required,
+        "SubBiome",
+        DB.Object({
+          name: DB.Required({
+            comment: "The subbiome's name.",
+            type: DB.String({ minLength: 1 }),
+          }),
+        }),
+      ),
+      regions: DB.Required({
+        type: DB.ChildEntities(BotanicRegion),
+      }),
+    }),
+  parentReferenceKey: "parent",
+  instanceDisplayName: {},
+  uniqueConstraints: [
+    {
+      entityMapKeyPath: "translations",
+      keyPathInEntityMap: "name",
+    },
+  ],
+})
@@ -30,6 +30,8 @@ export { Container } from "./equipment/item/Container.js"
 export { Elixir } from "./equipment/item/Elixir.js"
 export { EquipmentOfBlessedOnes } from "./equipment/item/EquipmentOfBlessedOnes.js"
 export { GemOrPreciousStone } from "./equipment/item/GemOrPreciousStone.js"
+export { HerbalAid } from "./equipment/item/HerbalAid.js"
+export { HerbalPreservation } from "./equipment/item/HerbalPreservation.js"
 export { IlluminationLightSource } from "./equipment/item/IlluminationLightSource.js"
 export { IlluminationRefillOrSupply } from "./equipment/item/IlluminationRefillOrSupply.js"
 export { Jewelry } from "./equipment/item/Jewelry.js"
@@ -40,18 +42,22 @@ export { MagicalArtifact } from "./equipment/item/MagicalArtifact.js"
 export { MusicalInstrument } from "./equipment/item/MusicalInstrument.js"
 export { Newspaper } from "./equipment/item/Newspaper.js"
 export { OrienteeringAid } from "./equipment/item/OrienteeringAid.js"
+export { Plant } from "./equipment/item/Plant.js"
 export { Poison } from "./equipment/item/Poison.js"
 export { RopeOrChain } from "./equipment/item/RopeOrChain.js"
 export { Stationery } from "./equipment/item/Stationery.js"
 export { ArmorType } from "./equipment/item/sub/ArmorType.js"
+export { Biome } from "./equipment/item/sub/Biome.js"
+export { SubBiome } from "./equipment/item/sub/SubBiome.js"
 export { Reach } from "./equipment/item/sub/Reach.js"
+export { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js"
 export { ThievesTool } from "./equipment/item/ThievesTool.js"
 export { ToolOfTheTrade } from "./equipment/item/ToolOfTheTrade.js"
 export { TravelGearOrTool } from "./equipment/item/TravelGearOrTool.js"
 export { Vehicle } from "./equipment/item/Vehicle.js"
 export { Weapon } from "./equipment/item/Weapon.js"
 export { WeaponAccessory } from "./equipment/item/WeaponAccessory.js"
-export { WorkingSupernaturalCreature } from "./equipment/item/WorkingSupernaturalCreature.ts"
+export { WorkingSupernaturalCreature } from "./equipment/item/WorkingSupernaturalCreature.js"
 export { ExperienceLevel } from "./ExperienceLevel.js"
 export { EyeColor } from "./EyeColor.js"
 export { FamiliarsTrick } from "./FamiliarsTrick.js"
@@ -142,11 +148,14 @@ export { ChronicleEnchantment } from "./traditionArtifacts/ChronicleEnchantment.
 export { DaggerRitual } from "./traditionArtifacts/DaggerRitual.js"
 export { FoolsHatEnchantment } from "./traditionArtifacts/FoolsHatEnchantment.js"
 export { Haubenzauber } from "./traditionArtifacts/Haubenzauber.js"
+export { Hauerkettenzauber } from "./traditionArtifacts/Hauerkettenzauber.js"
 export { InstrumentEnchantment } from "./traditionArtifacts/InstrumentEnchantment.js"
+export { Keulenzauber } from "./traditionArtifacts/Keulenzauber.js"
 export { Krallenkettenzauber } from "./traditionArtifacts/Krallenkettenzauber.js"
 export { Kristallkugelzauber } from "./traditionArtifacts/Kristallkugelzauber.js"
 export { OrbEnchantment } from "./traditionArtifacts/OrbEnchantment.js"
 export { RingEnchantment } from "./traditionArtifacts/RingEnchantment.js"
+export { Schweinetrommelzauber } from "./traditionArtifacts/Schweinetrommelzauber.js"
 export { SickleRitual } from "./traditionArtifacts/SickleRitual.js"
 export { SpellSwordEnchantment } from "./traditionArtifacts/SpellSwordEnchantment.js"
 export { StaffEnchantment } from "./traditionArtifacts/StaffEnchantment.js"
@@ -1,13 +1,14 @@
 import * as DB from "tsondb/schema/dsl"
 import { name_in_library } from "../_Activatable.js"
 import { OldParameter } from "../_ActivatableSkill.js"
-import { CheckResultBasedDuration, DurationUnitValue } from "../_ActivatableSkillDuration.js"
+import { DurationUnitValue, ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
 import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
+import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.ts"
 import { PropertyIdentifier, TribeIdentifier } from "../_Identifier.js"
 import { ImprovementCost } from "../_ImprovementCost.js"
 import { AnimistPowerPrerequisites } from "../_Prerequisite.js"
 import { ResponsiveTextOptional } from "../_ResponsiveText.js"
-import { SkillCheck } from "../_SkillCheck.js"
+import { SkillCheck, SkillCheckPenalty } from "../_SkillCheck.js"
 import { NestedTranslationMap } from "../Locale.js"
 import { Errata } from "../source/_Erratum.js"
 import { PublicationRefs, src } from "../source/_PublicationRef.js"
@@ -21,10 +22,18 @@ export const AnimistPower = DB.Entity(import.meta.url, {
        comment: "Lists the linked three attributes used to make a skill check.",
        type: DB.IncludeIdentifier(SkillCheck),
      }),
+      check_penalty: DB.Optional({
+        comment: "In some cases, the target's Spirit or Toughness is applied as a penalty.",
+        type: DB.IncludeIdentifier(SkillCheckPenalty),
+      }),
      parameters: DB.Required({
        comment: "Measurable parameters of an animist power.",
        type: DB.IncludeIdentifier(AnimistPowerPerformanceParameters),
      }),
+      target: DB.Optional({
+        comment: "The target category – the kind of creature or object – the skill affects.",
+        type: DB.IncludeIdentifier(AffectedTargetCategories),
+      }),
      property: DB.Required({
        comment: "The associated property.",
        type: PropertyIdentifier(),
@@ -190,8 +199,7 @@ const OneTimeAnimistPowerDuration = DB.Enum(import.meta.url, {
  name: "OneTimeAnimistPowerDuration",
  values: () => ({
    Immediate: DB.EnumCase({ type: null }),
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
-    CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
  }),
 })

@@ -1,8 +1,9 @@
 import * as DB from "tsondb/schema/dsl"
 import { name_in_library } from "../_Activatable.js"
-import { CheckResultBasedDuration } from "../_ActivatableSkillDuration.js"
+import { OneTimeCostMap } from "../_ActivatableSkillCost.ts"
+import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
 import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
-import { PropertyIdentifier, BannzeichenIdentifier } from "../_Identifier.js"
+import { BannzeichenIdentifier, PropertyIdentifier } from "../_Identifier.js"
 import { ImprovementCost } from "../_ImprovementCost.js"
 import { ResponsiveText, ResponsiveTextOptional } from "../_ResponsiveText.js"
 import { SkillCheck } from "../_SkillCheck.js"
@@ -111,6 +112,7 @@ const BannzeichenCost = DB.Enum(import.meta.url, {
  values: () => ({
    Single: DB.EnumCase({ type: DB.IncludeIdentifier(SingleBannzeichenCost) }),
    Disjunction: DB.EnumCase({ type: DB.IncludeIdentifier(BannzeichenCostDisjunction) }),
+    Map: DB.EnumCase({ type: DB.IncludeIdentifier(OneTimeCostMap) }),
    DerivedFromOption: DB.EnumCase({ type: null }),
  }),
 })
@@ -189,11 +191,11 @@ const BannzeichenDuration = DB.TypeAlias(import.meta.url, {
    DB.Object({
      slow: DB.Required({
        comment: "The duration on slow Bannzeichen application.",
-        type: DB.IncludeIdentifier(CheckResultBasedDuration),
+        type: DB.IncludeIdentifier(ExpressionBasedDuration),
      }),
      fast: DB.Required({
        comment: "The duration on fast Bannzeichen application.",
-        type: DB.IncludeIdentifier(CheckResultBasedDuration),
+        type: DB.IncludeIdentifier(ExpressionBasedDuration),
      }),
    }),
 })
@@ -236,10 +238,6 @@ export const BannzeichenOption = DB.Entity(import.meta.url, {
 The surrounding parenthesis will/should not be included, they will/should be generated.`,
            type: DB.String({ minLength: 1 }),
          }),
-          native_name: DB.Required({
-            comment: "The native name of the Bannzeichen option.",
-            type: DB.String({ minLength: 1 }),
-          }),
        }),
      ),
    }),
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { OldParameter } from "../_ActivatableSkill.js"
 import { IndefiniteOneTimeCost } from "../_ActivatableSkillCost.js"
-import { CheckResultBasedDuration, DurationUnitValue } from "../_ActivatableSkillDuration.js"
+import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
 import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
 import { PropertyIdentifier } from "../_Identifier.js"
 import { ResponsiveText, ResponsiveTextOptional } from "../_ResponsiveText.js"
@@ -125,8 +125,7 @@ const CurseDuration = DB.Enum(import.meta.url, {
  name: "CurseDuration",
  values: () => ({
    Immediate: DB.EnumCase({ type: null }),
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
-    CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
    Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteCurseDuration) }),
  }),
 })
@@ -155,7 +154,6 @@ const IndefiniteCurseDuration = DB.TypeAlias(import.meta.url, {
 const MaximumIndefiniteCurseDuration = DB.Enum(import.meta.url, {
  name: "MaximumIndefiniteCurseDuration",
  values: () => ({
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
-    CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
  }),
 })
@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl"
 import { OldParameter } from "../_ActivatableSkill.js"
-import { CheckResultBasedDuration, DurationUnit } from "../_ActivatableSkillDuration.js"
+import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
 import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
 import { PropertyIdentifier, SkillModificationLevelIdentifier } from "../_Identifier.js"
 import { ResponsiveText } from "../_ResponsiveText.js"
@@ -107,27 +107,11 @@ const DominationRitualCost = DB.TypeAlias(import.meta.url, {
 const DominationRitualDuration = DB.Enum(import.meta.url, {
  name: "DominationRitualDuration",
  values: () => ({
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedDominationRitualDuration) }),
-    CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
    Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteDominationRitualDuration) }),
  }),
 })

-const FixedDominationRitualDuration = DB.TypeAlias(import.meta.url, {
-  name: "FixedDominationRitualDuration",
-  type: () =>
-    DB.Object({
-      value: DB.Required({
-        comment: "The (unitless) duration.",
-        type: DB.Integer({ minimum: 1 }),
-      }),
-      unit: DB.Required({
-        comment: "The duration unit.",
-        type: DB.IncludeIdentifier(DurationUnit),
-      }),
-    }),
-})
-
 const IndefiniteDominationRitualDuration = DB.TypeAlias(import.meta.url, {
  name: "IndefiniteDominationRitualDuration",
  type: () =>
@@ -152,7 +136,6 @@ const IndefiniteDominationRitualDuration = DB.TypeAlias(import.meta.url, {
 const MaximumIndefiniteDominationRitualDuration = DB.Enum(import.meta.url, {
  name: "MaximumIndefiniteDominationRitualDuration",
  values: () => ({
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedDominationRitualDuration) }),
-    CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
  }),
 })
@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl"
 import { OldParameter } from "../_ActivatableSkill.js"
 import { SlowSkillNonModifiableCastingTime } from "../_ActivatableSkillCastingTime.js"
 import { OneTimeCostMap } from "../_ActivatableSkillCost.js"
-import { CheckResultBasedDuration, DurationUnitValue } from "../_ActivatableSkillDuration.js"
+import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
 import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
 import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.js"
 import { PropertyIdentifier } from "../_Identifier.js"
@@ -152,7 +152,6 @@ const GeodeRitualDuration = DB.Enum(import.meta.url, {
  name: "GeodeRitualDuration",
  values: () => ({
    Immediate: DB.EnumCase({ type: null }),
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
-    CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
  }),
 })
@@ -1,17 +1,17 @@
 import * as DB from "tsondb/schema/dsl"
 import { OldParameter } from "../_ActivatableSkill.js"
-import { CheckResultBasedDuration, DurationUnitValue } from "../_ActivatableSkillDuration.js"
-import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
 import { NonModifiableOneTimeCost, NonModifiableSustainedCost } from "../_ActivatableSkillCost.js"
-import { ResponsiveTextOptional, ResponsiveTextReplace } from "../_ResponsiveText.js"
-import { FixedRange } from "../_ActivatableSkillRange.js"
+import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
+import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
+import { ExpressionBasedRange } from "../_ActivatableSkillRange.js"
 import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.js"
 import { PropertyIdentifier } from "../_Identifier.js"
+import { ImprovementCost } from "../_ImprovementCost.js"
+import { ResponsiveTextOptional, ResponsiveTextReplace } from "../_ResponsiveText.js"
 import { SkillCheck, SkillCheckPenalty } from "../_SkillCheck.js"
 import { NestedTranslationMap } from "../Locale.js"
 import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
-import { ImprovementCost } from "../_ImprovementCost.js"

 export const GoblinRitual = DB.Entity(import.meta.url, {
  name: "GoblinRitual",
@@ -212,7 +212,7 @@ const GoblinRitualRangeValue = DB.Enum(import.meta.url, {
    Sight: DB.EnumCase({ type: null }),
    Self: DB.EnumCase({ type: null }),
    Touch: DB.EnumCase({ type: null }),
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedRange) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedRange) }),
  }),
 })

@@ -220,7 +220,6 @@ const GoblinRitualDuration = DB.Enum(import.meta.url, {
  name: "GoblinRitualDuration",
  values: () => ({
    Immediate: DB.EnumCase({ type: null }),
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
-    CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
  }),
 })
@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl"
 import { OldParameter } from "../_ActivatableSkill.js"
-import { CheckResultBasedDuration, DurationUnit } from "../_ActivatableSkillDuration.js"
+import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
 import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
 import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.js"
 import { PropertyIdentifier } from "../_Identifier.js"
@@ -158,22 +158,6 @@ export const JesterTrickDuration = DB.Enum(import.meta.url, {
  name: "JesterTrickDuration",
  values: () => ({
    Immediate: DB.EnumCase({ type: null }),
-    Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedJesterTrickDuration) }),
-    CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+    Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
  }),
 })
-
-const FixedJesterTrickDuration = DB.TypeAlias(import.meta.url, {
-  name: "FixedJesterTrickDuration",
-  type: () =>
-    DB.Object({
-      value: DB.Required({
-        comment: "The (unitless) duration.",
-        type: DB.Integer({ minimum: 2 }),
-      }),
-      unit: DB.Required({
-        comment: "The duration unit.",
-        type: DB.IncludeIdentifier(DurationUnit),
-      }),
-    }),
-})
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { name_in_library } from "../_Activatable.js"
 import { OldParameter } from "../_ActivatableSkill.js"
-import { CheckResultBasedDuration } from "../_ActivatableSkillDuration.js"
+import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.ts"
 import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
 import { MagicalRuneIdentifier, PropertyIdentifier } from "../_Identifier.js"
 import { CombatTechniqueIdentifier } from "../_IdentifierGroup.js"
@@ -259,11 +259,11 @@ const MagicalRuneDuration = DB.TypeAlias(import.meta.url, {
    DB.Object({
      slow: DB.Required({
        comment: "The duration on slow rune application.",
-        type: DB.IncludeIdentifier(CheckResultBasedDuration),
+        type: DB.IncludeIdentifier(ExpressionBasedDuration),
      }),
      fast: DB.Required({
        comment: "The duration on fast rune application.",
-        type: DB.IncludeIdentifier(CheckResultBasedDuration),
+        type: DB.IncludeIdentifier(ExpressionBasedDuration),
      }),
    }),
 })
@@ -78,6 +78,7 @@ export const GeneralPrerequisiteGroup = DB.Enum(import.meta.url, {
    SexualCharacteristic: DB.EnumCase({
      type: DB.IncludeIdentifier(SexualCharacteristicPrerequisite),
    }),
+    PersonalityTrait: DB.EnumCase({ type: DB.IncludeIdentifier(PersonalityTraitPrerequisite) }),
  }),
 })

@@ -0,0 +1,18 @@
+import * as DB from "tsondb/schema/dsl"
+import { PropertyIdentifier } from "../../_Identifier.js"
+import { DisplayOption } from "../DisplayOption.js"
+
+export const PropertyPrerequisite = DB.TypeAlias(import.meta.url, {
+  name: "PropertyPrerequisite",
+  comment: "Requires a specific property or one of a specific set of properties.",
+  type: () =>
+    DB.Object({
+      id: DB.Required({
+        comment: "The property�s identifier.",
+        type: PropertyIdentifier(),
+      }),
+      display_option: DB.Optional({
+        type: DB.IncludeIdentifier(DisplayOption),
+      }),
+    }),
+})
@@ -1,8 +1,8 @@
 import * as DB from "tsondb/schema/dsl"
 import { input, levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { combat_techniques, penalty, usage_type } from "../_ActivatableCombat.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { combat_techniques, penalty, special_ability_usage_type } from "../_ActivatableCombat.js"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
@@ -18,7 +18,7 @@ export const AdvancedCombatSpecialAbility = DB.Entity(import.meta.url, {
    DB.Object({
      levels,
      nameBuilderRules,
-      usage_type,
+      usage_type: special_ability_usage_type,
      select_options,
      explicit_select_options,
      skill_applications,
@@ -48,6 +48,7 @@ export const AdvancedCombatSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
@@ -43,6 +43,7 @@ export const AdvancedKarmaSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
@@ -43,6 +43,7 @@ export const AdvancedMagicalSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
@@ -43,6 +43,7 @@ export const AdvancedSkillSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -44,6 +44,7 @@ export const AncestorGlyph = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,6 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { name, name_in_library } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { activatableDisplayNameCustomizer } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import {
@@ -35,6 +36,11 @@ export const BlessedTradition = DB.Entity(import.meta.url, {
        comment: "The tradition’s aspects, if any.",
        type: DB.Array(AspectIdentifier(), { minItems: 2, maxItems: 2 }),
      }),
+      primaryBlessing: DB.Optional({
+        comment:
+          "The tradition’s primary blessing. Leave empty if the tradition does not have one.",
+        type: BlessingIdentifier(),
+      }),
      restricted_blessings: DB.Optional({
        comment:
          "If a tradition restricts the possible blessings, the blessings that are **not** allowed.",
@@ -96,6 +102,7 @@ export const BlessedTradition = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,8 +1,8 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { combat_techniques, usage_type } from "../_ActivatableCombat.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { combat_techniques, special_ability_usage_type } from "../_ActivatableCombat.js"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -16,7 +16,7 @@ export const BrawlingSpecialAbility = DB.Entity(import.meta.url, {
    DB.Object({
      levels,
      nameBuilderRules,
-      usage_type,
+      usage_type: special_ability_usage_type,
      select_options,
      explicit_select_options,
      maximum,
@@ -42,6 +42,7 @@ export const BrawlingSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { aspectOptional } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
@@ -44,6 +44,7 @@ export const CeremonialItemSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    [
      {
@@ -1,8 +1,13 @@
 import * as DB from "tsondb/schema/dsl"
 import { input, levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { combat_techniques, penalty, penalty_l10n, usage_type } from "../_ActivatableCombat.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import {
+  combat_techniques,
+  penalty,
+  penalty_l10n,
+  special_ability_usage_type,
+} from "../_ActivatableCombat.js"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
@@ -17,7 +22,7 @@ export const CombatSpecialAbility = DB.Entity(import.meta.url, {
    DB.Object({
      levels,
      nameBuilderRules,
-      usage_type,
+      usage_type: special_ability_usage_type,
      select_options,
      explicit_select_options,
      skill_applications,
@@ -48,6 +53,7 @@ export const CombatSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -2,8 +2,8 @@ import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { advanced } from "../_ActivatableAdvanced.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { combat_techniques, penalty, type, usage_type } from "../_ActivatableCombat.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { combat_techniques, penalty, type, style_usage_type } from "../_ActivatableCombat.js"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { AdvancedCombatSpecialAbilityIdentifier } from "../_Identifier.js"
@@ -19,7 +19,7 @@ export const CombatStyleSpecialAbility = DB.Entity(import.meta.url, {
    DB.Object({
      levels,
      nameBuilderRules,
-      usage_type,
+      usage_type: style_usage_type,
      type,
      select_options,
      explicit_select_options,
@@ -50,6 +50,7 @@ export const CombatStyleSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,8 +1,8 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { combat_techniques, usage_type } from "../_ActivatableCombat.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { combat_techniques, special_ability_usage_type } from "../_ActivatableCombat.js"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -16,7 +16,7 @@ export const CommandSpecialAbility = DB.Entity(import.meta.url, {
    DB.Object({
      levels,
      nameBuilderRules,
-      usage_type,
+      usage_type: special_ability_usage_type,
      select_options,
      explicit_select_options,
      maximum,
@@ -42,6 +42,7 @@ export const CommandSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -39,6 +39,7 @@ export const FamiliarSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -39,6 +39,7 @@ export const FatePointSexSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
@@ -42,6 +42,7 @@ export const FatePointSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { input, levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
@@ -43,6 +43,7 @@ export const GeneralSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -39,6 +39,7 @@ export const KarmaSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { advanced } from "../_ActivatableAdvanced.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { AdvancedKarmaSpecialAbilityIdentifier } from "../_Identifier.js"
@@ -45,6 +45,7 @@ export const LiturgicalStyleSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -39,6 +39,7 @@ export const LycantropicGift = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,8 +1,8 @@
 import * as DB from "tsondb/schema/dsl"
-import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
+import { additionalName, levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { advanced } from "../_ActivatableAdvanced.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { AdvancedMagicalSpecialAbilityIdentifier } from "../_Identifier.js"
@@ -34,6 +34,7 @@ export const MagicStyleSpecialAbility = DB.Entity(import.meta.url, {
        "MagicStyleSpecialAbility",
        DB.Object({
          name,
+          additionalName,
          name_in_library,
          rules,
          ap_value_append,
@@ -45,6 +46,7 @@ export const MagicStyleSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,6 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { effect, name, name_in_library } from "../_Activatable.js"
 import { ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { activatableDisplayNameCustomizer } from "../_ActivatableNames.ts"
 import { propertyOptional } from "../_ActivatableNonMundane.js"
 import { OneTimeCostMap } from "../_ActivatableSkillCost.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
@@ -42,6 +43,7 @@ export const MagicalSign = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { input, levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
@@ -43,6 +43,7 @@ export const MagicalSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, name, name_in_library } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import {
@@ -115,6 +115,7 @@ export const MagicalTradition = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl"
 import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
 import { automatic_entries } from "../_ActivatableAutomatic.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -45,6 +45,7 @@ export const PactGift = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -50,6 +50,7 @@ export const ProtectiveWardingCircleSpecialAbility = DB.Entity(import.meta.url,
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -39,6 +39,7 @@ export const Sermon = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
@@ -42,6 +42,7 @@ export const SexSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -39,6 +39,7 @@ export const SikaryanDrainSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { advanced } from "../_ActivatableAdvanced.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { AdvancedSkillStyleSpecialAbilityIdentifier } from "../_IdentifierGroup.ts"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
@@ -42,6 +42,7 @@ export const SkillStyleSpecialAbility = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -39,6 +39,7 @@ export const VampiricGift = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl"
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
-import { nameBuilderRules } from "../_ActivatableNames.ts"
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
 import { NestedTranslationMap } from "../Locale.js"
@@ -39,6 +39,7 @@ export const Vision = DB.Entity(import.meta.url, {
      ),
    }),
  instanceDisplayName: {},
+  instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
  uniqueConstraints: [
    {
      entityMapKeyPath: "translations",
@@ -16,7 +16,7 @@ export const Language = DB.Entity(import.meta.url, {
        comment: "The continents this language is present on.",
        type: DB.Array(DB.IncludeIdentifier(AssociatedContinent), { minItems: 1 }),
      }),
-      specializations: DB.Optional({
+      specializations: DB.Required({
        type: DB.ChildEntities(LanguageSpecialization),
      }),
      customSpecializations: DB.Optional({
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const ArcaneOrbEnchantment = DB.Entity(import.meta.url, {
  name: "ArcaneOrbEnchantment",
@@ -34,23 +26,7 @@ export const ArcaneOrbEnchantment = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "ArcaneOrbEnchantment",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("ArcaneOrbEnchantment"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const AttireEnchantment = DB.Entity(import.meta.url, {
  name: "AttireEnchantment",
@@ -34,23 +26,7 @@ export const AttireEnchantment = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "AttireEnchantment",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("AttireEnchantment"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const Beutelzauber = DB.Entity(import.meta.url, {
  name: "Beutelzauber",
@@ -34,23 +26,7 @@ export const Beutelzauber = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "Beutelzauber",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("Beutelzauber"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const BowlEnchantment = DB.Entity(import.meta.url, {
  name: "BowlEnchantment",
@@ -34,23 +26,7 @@ export const BowlEnchantment = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "BowlEnchantment",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("BowlEnchantment"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,21 +1,13 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { BrewIdentifier } from "../_Identifier.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const CauldronEnchantment = DB.Entity(import.meta.url, {
  name: "CauldronEnchantment",
@@ -40,23 +32,7 @@ export const CauldronEnchantment = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "CauldronEnchantment",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("CauldronEnchantment"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const ChronicleEnchantment = DB.Entity(import.meta.url, {
  name: "ChronicleEnchantment",
@@ -34,23 +26,7 @@ export const ChronicleEnchantment = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "ChronicleEnchantment",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("ChronicleEnchantment"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,21 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  ArcaneEnergyCost,
-  BindingCost,
-  bindingCost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { ArcaneEnergyCost, BindingCost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const DaggerRitual = DB.Entity(import.meta.url, {
  name: "DaggerRitual",
@@ -37,23 +28,7 @@ export const DaggerRitual = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "DaggerRitual",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("DaggerRitual"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const FoolsHatEnchantment = DB.Entity(import.meta.url, {
  name: "FoolsHatEnchantment",
@@ -36,23 +28,7 @@ export const FoolsHatEnchantment = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "FoolsHatEnchantment",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("FoolsHatEnchantment"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const Haubenzauber = DB.Entity(import.meta.url, {
  name: "Haubenzauber",
@@ -34,23 +26,7 @@ export const Haubenzauber = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "Haubenzauber",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("Haubenzauber"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -0,0 +1,36 @@
+import * as DB from "tsondb/schema/dsl"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
+import { nameBuilderRules } from "../_ActivatableNames.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
+import { GeneralPrerequisites } from "../_Prerequisite.js"
+import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.js"
+
+export const Hauerkettenzauber = DB.Entity(import.meta.url, {
+  name: "Hauerkettenzauber",
+  namePlural: "Hauerkettenzauber",
+  type: () =>
+    DB.Object({
+      levels,
+      nameBuilderRules,
+      maximum,
+      prerequisites: DB.Optional({
+        type: DB.IncludeIdentifier(GeneralPrerequisites),
+      }),
+      volume,
+      cost,
+      property: property(),
+      ap_value,
+      src,
+      translations: translations("Hauerkettenzauber"),
+    }),
+  instanceDisplayName: {},
+  uniqueConstraints: [
+    {
+      entityMapKeyPath: "translations",
+      keyPathInEntityMap: "name_in_library",
+      keyPathInEntityMapFallback: "name",
+    },
+  ],
+})
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const InstrumentEnchantment = DB.Entity(import.meta.url, {
  name: "InstrumentEnchantment",
@@ -34,23 +26,7 @@ export const InstrumentEnchantment = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "InstrumentEnchantment",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("InstrumentEnchantment"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -0,0 +1,37 @@
+import * as DB from "tsondb/schema/dsl"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
+import { nameBuilderRules } from "../_ActivatableNames.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
+import { GeneralPrerequisites } from "../_Prerequisite.js"
+import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.js"
+
+//Keulenzauber für Goblinzauberinnen
+export const Keulenzauber = DB.Entity(import.meta.url, {
+  name: "Keulenzauber",
+  namePlural: "Keulenzauber",
+  type: () =>
+    DB.Object({
+      levels,
+      nameBuilderRules,
+      maximum,
+      prerequisites: DB.Optional({
+        type: DB.IncludeIdentifier(GeneralPrerequisites),
+      }),
+      volume,
+      cost,
+      property: property(),
+      ap_value,
+      src,
+      translations: translations("Keulenzauber"),
+    }),
+  instanceDisplayName: {},
+  uniqueConstraints: [
+    {
+      entityMapKeyPath: "translations",
+      keyPathInEntityMap: "name_in_library",
+      keyPathInEntityMapFallback: "name",
+    },
+  ],
+})
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const Krallenkettenzauber = DB.Entity(import.meta.url, {
  name: "Krallenkettenzauber",
@@ -34,23 +26,7 @@ export const Krallenkettenzauber = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "Krallenkettenzauber",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("Krallenkettenzauber"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const Kristallkugelzauber = DB.Entity(import.meta.url, {
  name: "Kristallkugelzauber",
@@ -34,23 +26,7 @@ export const Kristallkugelzauber = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "Kristallkugelzauber",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("Kristallkugelzauber"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const OrbEnchantment = DB.Entity(import.meta.url, {
  name: "OrbEnchantment",
@@ -34,23 +26,7 @@ export const OrbEnchantment = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "OrbEnchantment",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("OrbEnchantment"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const RingEnchantment = DB.Entity(import.meta.url, {
  name: "RingEnchantment",
@@ -34,23 +26,7 @@ export const RingEnchantment = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "RingEnchantment",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("RingEnchantment"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -0,0 +1,36 @@
+import * as DB from "tsondb/schema/dsl"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
+import { nameBuilderRules } from "../_ActivatableNames.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
+import { GeneralPrerequisites } from "../_Prerequisite.js"
+import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.js"
+
+export const Schweinetrommelzauber = DB.Entity(import.meta.url, {
+  name: "Schweinetrommelzauber",
+  namePlural: "Schweinetrommelzauber",
+  type: () =>
+    DB.Object({
+      levels,
+      nameBuilderRules,
+      maximum,
+      prerequisites: DB.Optional({
+        type: DB.IncludeIdentifier(GeneralPrerequisites),
+      }),
+      volume,
+      cost,
+      property: property(),
+      ap_value,
+      src,
+      translations: translations("Schweinetrommelzauber"),
+    }),
+  instanceDisplayName: {},
+  uniqueConstraints: [
+    {
+      entityMapKeyPath: "translations",
+      keyPathInEntityMap: "name_in_library",
+      keyPathInEntityMapFallback: "name",
+    },
+  ],
+})
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const SickleRitual = DB.Entity(import.meta.url, {
  name: "SickleRitual",
@@ -34,23 +26,7 @@ export const SickleRitual = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "SickleRitual",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("SickleRitual"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,20 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const SpellSwordEnchantment = DB.Entity(import.meta.url, {
  name: "SpellSwordEnchantment",
@@ -34,23 +26,7 @@ export const SpellSwordEnchantment = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "SpellSwordEnchantment",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("SpellSwordEnchantment"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
@@ -1,21 +1,12 @@
 import * as DB from "tsondb/schema/dsl"
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
+import { levels, maximum } from "../_Activatable.js"
+import { ap_value } from "../_ActivatableAdventurePointsValue.js"
 import { nameBuilderRules } from "../_ActivatableNames.ts"
-import {
-  aeCost,
-  bindingCost,
-  cost,
-  property,
-  volume,
-  volume_l10n,
-} from "../_ActivatableNonMundane.js"
+import { cost, property, volume } from "../_ActivatableNonMundane.js"
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
 import { GeneralPrerequisites } from "../_Prerequisite.js"
-import { ResponsiveTextOptional } from "../_ResponsiveText.js"
-import { NestedTranslationMap } from "../Locale.js"
-import { Errata } from "../source/_Erratum.js"
 import { src } from "../source/_PublicationRef.js"
+import { translations } from "./_shared.ts"

 export const StaffEnchantment = DB.Entity(import.meta.url, {
  name: "StaffEnchantment",
@@ -35,27 +26,7 @@ export const StaffEnchantment = DB.Entity(import.meta.url, {
      property: property(),
      ap_value,
      src,
-      translations: NestedTranslationMap(
-        DB.Required,
-        "StaffEnchantment",
-        DB.Object({
-          name,
-          name_in_library,
-          effect,
-          cost_note: DB.Optional({
-            comment: "A note, appended to the generated cost string in parenthesis.",
-            type: DB.IncludeIdentifier(ResponsiveTextOptional),
-          }),
-          bindingCost,
-          aeCost,
-          volume: volume_l10n,
-          ap_value_append,
-          ap_value: ap_value_l10n,
-          errata: DB.Optional({
-            type: DB.IncludeIdentifier(Errata),
-          }),
-        }),
-      ),
+      translations: translations("StaffEnchantment"),
    }),
  instanceDisplayName: {},
  uniqueConstraints: [
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Lector	9718f7d341	feat!: derived select options based on property Refs: #175 Closes #174	2026-06-27 14:55:52 +02:00
Lector	0c8f3518ea	feat!: active usage type for combat styles Refs: #171 Closes #170 Reviewed-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-27 14:06:46 +02:00
Lukas Obermann	3b3ae6f3a6	feat: optional additional name for magic styles	2026-06-24 22:19:55 +02:00
Lukas Obermann	028e438909	fix!: remove bannzeichen option native name	2026-06-21 22:53:25 +02:00
Lukas Obermann	04f2a32a5e	build(release): 0.53.0 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-21 21:46:25 +02:00
Lukas Obermann	0e25dbf4a7	feat!: add bannzeichen cost map	2026-06-21 21:46:15 +02:00
Lukas Obermann	7e977925b5	feat: separate tradition artifact enhancement identifiers Still includes them in SpecialAbilityIdentifier group, but now have their own group as well.	2026-06-21 21:28:44 +02:00
Lukas Obermann	11cadd76ba	build(release): 0.52.2 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-21 14:28:11 +02:00
Lukas Obermann	249af59f6a	fix: combined unique constraint for botanic regions	2026-06-21 14:28:05 +02:00
Lukas Obermann	bb7d59e8b7	build(release): 0.52.1 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-20 08:54:41 +02:00
Lector	1e30f55407	feat: optional translation for combat technique restrictions Refs: #169 Closes #168 Reviewed-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-20 08:54:20 +02:00
Lukas Obermann	b70343ba6e	build(release): 0.52.0 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-19 16:49:38 +02:00
Lector	3b522aa9d7	feat: botanic region uniqueness per parent Refs: #166 Closes #165 Reviewed-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-19 16:43:50 +02:00
Lector	894fe21536	feat!: enchantment cost map Refs: #167 Closes #164	2026-06-19 16:40:55 +02:00
Lukas Obermann	e89c4390be	build(release): 0.51.0 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-18 20:44:19 +02:00
Lector	da1d2459db	feat: add schemas for goblin tradition artifact enchantments Refs: #163 Closes #162 Reviewed-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-18 20:43:41 +02:00
Lector	6c62616285	feat!: rework plants schema Refs: #161 Closes #160	2026-06-18 14:52:54 +02:00
Lukas Obermann	6c6d7a07fd	build(release): 0.50.1 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-14 17:56:01 +02:00
Lukas Obermann	9d97dd4ec9	feat: primary blessing for tradition This is used to complete each blessing’s tradition list.	2026-06-14 17:55:53 +02:00
Lector	27236a7588	feat: trade secrets for herbal aids Refs: #159 Closes #158	2026-06-14 17:25:19 +02:00
Lukas Obermann	959a5f1038	build(release): 0.50.0 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-14 14:14:05 +02:00
Lukas Obermann	3a3af6e574	feat: allow arbitrary text input for enhancements	2026-06-14 14:13:55 +02:00
Lukas Obermann	1d06407eb4	feat!: allow arbitrary AP values for enhancements	2026-06-14 14:04:37 +02:00
Lukas Obermann	89c5a10597	refactor: remove unused check-result based types	2026-06-14 12:21:28 +02:00
Lukas Obermann	f6bb84fcb6	build(release): 0.49.0 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-14 00:12:31 +02:00
Lukas Obermann	64ee1cce6a	fix!: add missing skill rating case to parameter expression	2026-06-14 00:12:28 +02:00
Lukas Obermann	500a2631b9	build(release): 0.48.0 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-13 23:29:23 +02:00
Lukas Obermann	31798ca33f	feat!: unify some skill durations and ranges with expressions	2026-06-13 23:29:04 +02:00
Lukas Obermann	296962d3ce	build(release): 0.47.4 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-13 22:18:06 +02:00
Lukas Obermann	b5ece95103	feat: culture language translations	2026-06-13 22:18:00 +02:00
Lukas Obermann	88da9b1528	build(release): 0.47.3 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-13 13:47:04 +02:00
Lukas Obermann	cdb86e9aa6	feat: optional sources for skill applications This can be used to remove an application in a later revision of a book.	2026-06-13 13:46:50 +02:00
Lukas Obermann	b9e4fff14c	refactor: unify tradition artifact enchantment translations This also makes cost_note available to all enchantment entities.	2026-06-13 13:35:39 +02:00
Lukas Obermann	6c9f7a6ec2	fix: profession cantrips must be unique	2026-06-09 09:57:11 +02:00
Lector	a7b8e7ec0c	feat: level and options for automatic and str. rec. dis/advantages in sub-races Changed automatic dis/advantages in the sub-race so they take the same parameters as the other dis/advantages. Closes #150 Reviewed-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-08 15:05:38 +02:00
Lukas Obermann	13c0d5c6ba	build(release): 0.47.2 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-08 10:53:30 +02:00
Lukas Obermann	aa556a48c8	feat: optional target category for animist powers	2026-06-08 10:53:25 +02:00
Lukas Obermann	fbd29a6e93	build(release): 0.47.1 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-08 10:46:07 +02:00
Lukas Obermann	9ed6e70645	feat: skill check penalty for animist powers	2026-06-08 10:45:57 +02:00
Lukas Obermann	af43af87de	fix: personality trait effect supports markdown	2026-06-07 23:22:14 +02:00
Lukas Obermann	99fb31e053	build(release): 0.47.0 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-07 23:16:29 +02:00
Lukas Obermann	4c2228b6d7	fix!: interval for sustained cost map Closes #145	2026-06-07 23:16:16 +02:00
Lukas Obermann	737fe3742c	feat: fixed cantrips for base profession package Closes #148	2026-06-07 23:13:07 +02:00
Lukas Obermann	1f28470b8f	feat: note for commonness-rated entries Closes #146	2026-06-07 23:10:47 +02:00
Lukas Obermann	d4ffbb9111	feat!: personality trait as activatable prerequisite	2026-06-07 23:08:43 +02:00
Lukas Obermann	0284b1dbae	build(release): 0.46.0 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-07 12:42:48 +02:00
Lukas Obermann	47f9e890bb	feat!: allow blessed profession	2026-06-07 12:42:40 +02:00
Lukas Obermann	96d70f7237	fix: required language specializations Language specializations must be as they are a child entity and cannot be displayed otherwise.	2026-06-07 12:42:17 +02:00
Lukas Obermann	a9ea59a802	feat: use library name as display name if available	2026-06-06 15:15:33 +02:00
Lector	ae45659ff9	feat: plants entity Refs: #142 Closes #3 Reviewed-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-06-04 13:45:30 +02:00
Lukas Obermann	2be0fb3c50	docs: explain responsive text in module doc	2026-06-03 15:21:38 +02:00
Lukas Obermann	c3654151f0	build(release): 0.45.0 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-05-31 15:07:14 +02:00
Lukas Obermann	64e7ed1035	feat!: add maximum sr translation	2026-05-31 15:07:11 +02:00
Lukas Obermann	84d5023ea3	build(release): 0.44.1 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-05-31 13:00:11 +02:00
Lukas Obermann	c147d16130	feat: full commonness-rated text replacement	2026-05-31 13:00:05 +02:00
Lukas Obermann	97671ca215	build(release): 0.44.0 Signed-off-by: Lukas Obermann <lukas.obermann@icloud.com>	2026-05-30 09:54:08 +02:00
Lukas Obermann	7fc5fd144a	feat!: diease and poison options can be required	2026-05-30 09:54:05 +02:00