@optolith/database-schema 0.108.1 → 0.109.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 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.109.0](https://github.com/Optolith/database-schema/compare/v0.108.1...v0.109.0) (2026-10-17)
+
+### ⚠ BREAKING CHANGES
+
+* item component references special ammunition only
+
+### Features
+
+* special ammunition entity ([0b149a9](https://github.com/Optolith/database-schema/commit/0b149a9073f02f425cb56c52c0b4e60b819b3024))
+
+### Bug Fixes
+
+* derived trade secrets for special ammunition ([83b8d14](https://github.com/Optolith/database-schema/commit/83b8d1410886d87b6f790fa4bb96c100f5c04ee8))
+* item component references special ammunition only ([a200ecd](https://github.com/Optolith/database-schema/commit/a200ecd5bd31e4d4bdc4cf1f13f11d73b22d88ce))
+
 ## [0.108.1](https://github.com/Optolith/database-schema/compare/v0.108.0...v0.108.1) (2026-10-17)
 
 ### Bug Fixes

package/gen/types.d.ts

@@ -171,6 +171,7 @@ export type EntityMap = {
   SkillStyleSpecialAbility: SkillStyleSpecialAbility
   SkillUse: SkillUse
   SocialStatus: SocialStatus
+  SpecialAmmunition: SpecialAmmunition
   Spell: Spell
   SpellSwordEnchantment: SpellSwordEnchantment
   StaffEnchantment: StaffEnchantment
@@ -26728,7 +26729,7 @@ export interface ApplicableAmmunition {
   /**
    * Specific ammunition this component can be applied to.
    */
-  ammunition?: Ammunition_ID[]
+  ammunition?: SpecialAmmunition_ID[]
 
   /**
    * Whether the list of ammunition is inverted, i.e. whether the component can be applied to all ammunition – or those of the specified category – except for the listed ammunition.
@@ -26741,6 +26742,69 @@ export interface ApplicableAmmunition {
   category?: ApplicableAmmunitionCategory
 }
 
+export interface SpecialAmmunition {
+  /**
+   * The base ammunition type that is affected by this specialization.
+   */
+  applicableTo: Ammunition_ID[]
+
+  /**
+   * The cost modifier for the base price of affected ammunition.
+   */
+  costModifier: number
+
+  /**
+   * The complexity of crafting the item.
+   */
+  complexity?: Complexity
+
+  /**
+   * The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.
+   */
+  prerequisites?: EquipmentPrerequisites
+
+  /**
+   * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
+   */
+  src: PublicationRefs
+
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: SpecialAmmunitionTranslation
+  }
+}
+
+/**
+ * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
+ */
+export type SpecialAmmunition_ID = string
+
+export interface SpecialAmmunitionTranslation {
+  /**
+   * The item’s name.
+   */
+  name: string
+
+  /**
+   * An auxiliary name or label of the item, if available.
+   */
+  secondary_name?: string
+
+  /**
+   * Note text.
+   */
+  note?: string
+
+  /**
+   * Special rules text.
+   */
+  rules?: string
+
+  errata?: Errata
+}
+
 export type ApplicableAmmunitionCategory =
   | {
     kind: "ArrowOrBolt"

package/lib/cache/tradeSecrets.d.ts

@@ -5,7 +5,7 @@ type EquipmentEntitiesWithComplexities = {
     [K in EquipmentIdentifier["kind"]]: EntityMap[K] extends {
         complexity?: Complexity | ArmorComplexity;
     } ? K : never;
-}[EquipmentIdentifier["kind"]];
+}[EquipmentIdentifier["kind"]] | "SpecialAmmunition";
 type HerbaryEntitiesWithTradeSecrets = "Disease" | "Elixir" | "HerbalAid" | "Poison";
 export type DerivedTradeSecretsCache = {
     equipment: {

package/lib/cache/tradeSecrets.js

@@ -22,6 +22,7 @@ const emptyDerivedEquipmentTradeSecretsCache = {
     MusicalInstrument: {},
     OrienteeringAid: {},
     RopeOrChain: {},
+    SpecialAmmunition: {},
     Stationery: {},
     ThievesTool: {},
     ToolOfTheTrade: {},

package/lib/main.js

@@ -153,6 +153,7 @@ export const schema = new Schema((await import("../package.json", { with: { type
     Types.SkillModificationLevel,
     Types.SkillStyleSpecialAbility,
     Types.SocialStatus,
+    Types.SpecialAmmunition,
     Types.Spell,
     Types.SpellSwordEnchantment,
     Types.StaffEnchantment,

package/lib/types/_Identifier.d.ts

@@ -161,6 +161,7 @@ export declare const SkillIdentifier: () => R;
 export declare const SkillModificationLevelIdentifier: () => R;
 export declare const SkillStyleSpecialAbilityIdentifier: () => R;
 export declare const SocialStatusIdentifier: () => R;
+export declare const SpecialAmmunitionIdentifier: () => R;
 export declare const SpellIdentifier: () => R;
 export declare const SpellSwordEnchantmentIdentifier: () => R;
 export declare const StaffEnchantmentIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -51,6 +51,7 @@ 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 { SpecialAmmunition } from "./equipment/item/SpecialAmmunition.js";
 import { Stationery } from "./equipment/item/Stationery.js";
 import { Biome } from "./equipment/item/sub/Biome.js";
 import { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js";
@@ -331,6 +332,7 @@ export const SkillIdentifier = () => R(Skill);
 export const SkillModificationLevelIdentifier = () => R(SkillModificationLevel);
 export const SkillStyleSpecialAbilityIdentifier = () => R(SkillStyleSpecialAbility);
 export const SocialStatusIdentifier = () => R(SocialStatus);
+export const SpecialAmmunitionIdentifier = () => R(SpecialAmmunition);
 export const SpellIdentifier = () => R(Spell);
 export const SpellSwordEnchantmentIdentifier = () => R(SpellSwordEnchantment);
 export const StaffEnchantmentIdentifier = () => R(StaffEnchantment);

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

@@ -1,5 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
-import { AmmunitionIdentifier, ArmorIdentifier, CloseCombatTechniqueIdentifier, ItemComponentIdentifier, RangedCombatTechniqueIdentifier, WeaponIdentifier, } from "../../_Identifier.js";
+import { ArmorIdentifier, CloseCombatTechniqueIdentifier, ItemComponentIdentifier, RangedCombatTechniqueIdentifier, SpecialAmmunitionIdentifier, WeaponIdentifier, } from "../../_Identifier.js";
 import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechnique.js";
 import { NestedTranslationMap } from "../../Locale.js";
@@ -258,7 +258,7 @@ const ApplicableAmmunition = DB.TypeAlias(import.meta.url, {
     type: () => DB.Object({
         ammunition: DB.Optional({
             comment: "Specific ammunition this component can be applied to.",
-            type: DB.Array(AmmunitionIdentifier(), {
+            type: DB.Array(SpecialAmmunitionIdentifier(), {
                 minItems: 1,
                 uniqueItems: true,
             }),

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

@@ -0,0 +1,152 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const SpecialAmmunition: DB.Entity<"SpecialAmmunition", {
+    applicableTo: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    costModifier: DB.MemberDecl<DB.Integer, true>;
+    complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Complexity", {
+        Primitive: DB.EnumCase<null>;
+        Simple: DB.EnumCase<null>;
+        Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
+            ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
+            src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+                id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+                    initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                        printing: DB.MemberDecl<DB.Integer, false>;
+                        pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                            first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                InsideCoverFront: DB.EnumCase<null>;
+                                InsideCoverBack: DB.EnumCase<null>;
+                                Numbered: DB.EnumCase<DB.Integer>;
+                            }, []>>, true>;
+                            last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                InsideCoverFront: DB.EnumCase<null>;
+                                InsideCoverBack: DB.EnumCase<null>;
+                                Numbered: DB.EnumCase<DB.Integer>;
+                            }, []>>, false>;
+                        }>, []>>>, true>;
+                        isRemoved: DB.MemberDecl<DB.Boolean, false>;
+                    }>, []>>, true>;
+                    revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                        Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                            printing: DB.MemberDecl<DB.Integer, true>;
+                            pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                                first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                    InsideCoverFront: DB.EnumCase<null>;
+                                    InsideCoverBack: DB.EnumCase<null>;
+                                    Numbered: DB.EnumCase<DB.Integer>;
+                                }, []>>, true>;
+                                last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                    InsideCoverFront: DB.EnumCase<null>;
+                                    InsideCoverBack: DB.EnumCase<null>;
+                                    Numbered: DB.EnumCase<DB.Integer>;
+                                }, []>>, false>;
+                            }>, []>>>, true>;
+                        }>, []>>>;
+                        Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                            printing: DB.MemberDecl<DB.Integer, true>;
+                        }>, []>>>;
+                    }, []>>>, false>;
+                }>, true>;
+            }>, []>>>, []>>, false>;
+        }>, []>>>;
+    }, []>>, false>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EquipmentPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
+    src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+        id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+            initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, false>;
+                pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                    first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, true>;
+                    last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+                isRemoved: DB.MemberDecl<DB.Boolean, false>;
+            }>, []>>, true>;
+            revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                    pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                        first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, true>;
+                        last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"SpecialAmmunitionTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        secondary_name: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
+        rules: DB.MemberDecl<DB.String, false>;
+        errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
+            date: DB.MemberDecl<DB.Date, true>;
+            description: DB.MemberDecl<DB.String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, undefined>;

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

@@ -0,0 +1,58 @@
+import * as DB from "tsondb/schema/dsl";
+import { AmmunitionIdentifier } from "../../_Identifier.js";
+import { EquipmentPrerequisites } from "../../_Prerequisite.js";
+import { NestedTranslationMap } from "../../Locale.js";
+import { Errata } from "../../source/_Erratum.js";
+import { src } from "../../source/_PublicationRef.js";
+import { Complexity } from "./_Item.js";
+export const SpecialAmmunition = DB.Entity(import.meta.url, {
+    name: "SpecialAmmunition",
+    namePlural: "SpecialAmmunition",
+    type: () => DB.Object({
+        applicableTo: DB.Required({
+            comment: "The base ammunition type that is affected by this specialization.",
+            type: DB.Array(AmmunitionIdentifier(), { minItems: 1 }),
+        }),
+        costModifier: DB.Required({
+            comment: "The cost modifier for the base price of affected ammunition.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        complexity: DB.Optional({
+            comment: "The complexity of crafting the item.",
+            type: DB.IncludeIdentifier(Complexity),
+        }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.",
+            type: DB.IncludeIdentifier(EquipmentPrerequisites),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "SpecialAmmunition", DB.Object({
+            name: DB.Required({
+                comment: "The item’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            secondary_name: DB.Optional({
+                comment: "An auxiliary name or label of the item, if available.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            note: DB.Optional({
+                comment: "Note text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            rules: DB.Optional({
+                comment: "Special rules text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/index.d.ts

@@ -49,6 +49,7 @@ 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 { SpecialAmmunition } from "./equipment/item/SpecialAmmunition.js";
 export { Stationery } from "./equipment/item/Stationery.js";
 export { Biome } from "./equipment/item/sub/Biome.js";
 export { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js";

package/lib/types/index.js

@@ -49,6 +49,7 @@ 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 { SpecialAmmunition } from "./equipment/item/SpecialAmmunition.js";
 export { Stationery } from "./equipment/item/Stationery.js";
 export { Biome } from "./equipment/item/sub/Biome.js";
 export { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js";

package/package.json

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