optolith-database-schema 0.36.1 → 0.38.0

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 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.38.0](https://github.com/elyukai/optolith-database-schema/compare/v0.37.0...v0.38.0) (2026-03-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* reconstruction and references can differ per edition
+
+### Features
+
+* display names for new skill applications and uses ([e3eaca0](https://github.com/elyukai/optolith-database-schema/commit/e3eaca0c25f6597bed456f6ae2edd0ff4afd2dae))
+* reconstruction and references can differ per edition ([8774da6](https://github.com/elyukai/optolith-database-schema/commit/8774da6c72786333b09235ee712d0864778dbbfe))
+
+## [0.37.0](https://github.com/elyukai/optolith-database-schema/compare/v0.36.1...v0.37.0) (2026-03-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* more detailed book rules and meta data
+
+### Features
+
+* more detailed book rules and meta data ([04b3a74](https://github.com/elyukai/optolith-database-schema/commit/04b3a7451e8ccc629b670da95b178f115085363b))
+
 ## [0.36.1](https://github.com/elyukai/optolith-database-schema/compare/v0.36.0...v0.36.1) (2026-03-13)
 
 

package/README.md

@@ -15,3 +15,20 @@ If you want to contribute to the database schema itself, please open an issue or
 ## Usage
 
 If you want to use the database (or parts of it) in your own project (most likely to support Optolith export formats in your own application), you can use the TypeScript sources as a simple database reader, at least if you have a project targeting JavaScript interpreters as well. This way, you already have proper typings. You can extract the database from the installation folder of Optolith and then configure the database reader to your needs.
+
+## Semantic Versioning
+
+The following situations are considered breaking changes:
+
+- Underlying data must be changed in order to comply with the new schema. Examples:
+  - Existing optional properties are made required
+  - New required properties are added
+  - Properties or enumeration cases are removed
+- Code that uses the data must be adjusted in order to use the new version. Examples:
+  - Existing required properties are made optional
+  - Enumeration cases are added
+  - Properties or enumeration cases are removed
+
+This implies that breaking changes can occur quite frequently, even if the changes are very small.
+
+A minor version bump can represent new optional properties, while patch version might represent adjustments in comments or display names for the editor.

package/gen/types.d.ts

@@ -237,8 +237,10 @@ export type EnumMap = {
   BlessedTraditionType: BlessedTraditionType
   BlessingDuration: BlessingDuration
   BlessingRange: BlessingRange
+  BookContentQuality: BookContentQuality
   BookCost: BookCost
   BookCostVariant: BookCostVariant
+  BookRules: BookRules
   BookType: BookType
   BurningTime: BurningTime
   CantripDuration: CantripDuration
@@ -484,6 +486,8 @@ export type TypeAliasMap = {
   BlessedTraditionPrerequisite: BlessedTraditionPrerequisite
   BlessedTraditionsSelectOptionCategory: BlessedTraditionsSelectOptionCategory
   BlessingPerformanceParameters: BlessingPerformanceParameters
+  BookRulesByEdition: BookRulesByEdition
+  BookRulesOfEdition: BookRulesOfEdition
   BySizeCategory: BySizeCategory<unknown>
   CalculationTranslation: CalculationTranslation
   CantripPerformanceParameters: CantripPerformanceParameters
@@ -703,6 +707,7 @@ export type TypeAliasMap = {
   PersonalityTraitEffect: PersonalityTraitEffect
   PersonalityTraitPrerequisite: PersonalityTraitPrerequisite
   PersonalityTraitPrerequisites: PersonalityTraitPrerequisites
+  PlainBookRules: PlainBookRules
   PlainCommonProfessions: PlainCommonProfessions
   PlainGeneralPrerequisites: PlainGeneralPrerequisites
   PlainPrerequisites: PlainPrerequisites<unknown>
@@ -2434,6 +2439,24 @@ export interface Locale {
     ".input {$count :number} {{check required every {$count}. application in the same month}}": string & { __params: { "count": number } }
     "see {$link}": string & { __params: { "link": StringableTranslationParameter } }
     "CoD": string
+    "Romance Novel": string
+    "Poetry": string
+    "Political Pamphlet": string
+    "Crime Story": string
+    "Fairy Tale": string
+    "Novel": string
+    "Professional Publication": string
+    "Magical Book": string
+    "Religious Works": string
+    "Content Quality": string
+    "Modest": string
+    "Average": string
+    "Demanding": string
+    "CL {$level}": string & { __params: { "level": StringableTranslationParameter } }
+    "Availability": string
+    "Reconstruction": string
+    "References": string
+    "Entertainment": string
     "Failed": string
     "Progress": string
     "Incubation Time": string
@@ -20016,6 +20039,11 @@ export interface Book {
    */
   structure_points?: StructurePoints
 
+  /**
+   * The quality of the book’s content.
+   */
+  contentQuality?: BookContentQuality
+
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
    */
@@ -20063,7 +20091,22 @@ export interface BookTranslation {
   /**
    * Special rules text.
    */
-  rules?: string
+  rules?: BookRules
+
+  /**
+   * The legality of the item, if specified.
+   */
+  legality?: string
+
+  /**
+   * The availability of the item, if specified.
+   */
+  availability?: string
+
+  /**
+   * Special properties or features of the item.
+   */
+  special?: string
 
   errata?: Errata
 }
@@ -20184,6 +20227,96 @@ export interface IndefiniteBookCostVariantTranslation {
   description: string
 }
 
+/**
+ * The quality of the book’s content.
+ */
+export type BookContentQuality =
+  | {
+    kind: "Modest"
+  }
+  | {
+    kind: "Average"
+  }
+  | {
+    kind: "Demanding"
+    Demanding: number
+  }
+
+/**
+ * Skills and abilities you can learn by reading the book, as well as any other rules and effects concerning the book.
+ */
+export type BookRules =
+  | {
+    kind: "Plain"
+    Plain: PlainBookRules
+  }
+  | {
+    kind: "Entertainment"
+  }
+  | {
+    kind: "ByEdition"
+    ByEdition: BookRulesByEdition
+  }
+
+/**
+ * The book’s rules without any special effects or conditions.
+ */
+export interface PlainBookRules {
+  /**
+   * The (main) rules text.
+   */
+  text: string
+
+  /**
+   * Rules for reconstructing certain skills or abilities from the book.
+   */
+  reconstruction?: string
+
+  /**
+   * References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.
+   */
+  references?: string
+
+  /**
+   * Additional rules text that comes after all other rules.
+   */
+  textAfter?: string
+}
+
+/**
+ * The book’s rules with differences between each edition and more differentiation between types of rules.
+ */
+export interface BookRulesByEdition {
+  editions: BookRulesOfEdition[]
+
+  /**
+   * Additional rules text that comes after all other rules.
+   */
+  textAfter?: string
+}
+
+export interface BookRulesOfEdition {
+  /**
+   * The edition(s) the rules apply to.
+   */
+  label: string
+
+  /**
+   * The rules text.
+   */
+  text: string
+
+  /**
+   * Rules for reconstructing certain skills or abilities from the book.
+   */
+  reconstruction?: string
+
+  /**
+   * References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.
+   */
+  references?: string
+}
+
 export interface CeremonialItem {
   /**
    * The cost in silverthalers.

package/lib/types/Locale.d.ts

@@ -1477,6 +1477,24 @@ export declare const Locale: DB.Entity<"Locale", {
         ".input {$count :number} {{check required every {$count}. application in the same month}}": null;
         "see {$link}": null;
         CoD: null;
+        "Romance Novel": null;
+        Poetry: null;
+        "Political Pamphlet": null;
+        "Crime Story": null;
+        "Fairy Tale": null;
+        Novel: null;
+        "Professional Publication": null;
+        "Magical Book": null;
+        "Religious Works": null;
+        "Content Quality": null;
+        Modest: null;
+        Average: null;
+        Demanding: null;
+        "CL {$level}": null;
+        Availability: null;
+        Reconstruction: null;
+        References: null;
+        Entertainment: null;
         Failed: null;
         Progress: null;
         "Incubation Time": null;

package/lib/types/Locale.js

@@ -1518,6 +1518,25 @@ export const Locale = DB.Entity(import.meta.url, {
                 ".input {$count :number} {{check required every {$count}. application in the same month}}": null,
                 "see {$link}": null,
                 "CoD": null,
+                // books
+                "Romance Novel": null,
+                "Poetry": null,
+                "Political Pamphlet": null,
+                "Crime Story": null,
+                "Fairy Tale": null,
+                "Novel": null,
+                "Professional Publication": null,
+                "Magical Book": null,
+                "Religious Works": null,
+                "Content Quality": null,
+                "Modest": null,
+                "Average": null,
+                "Demanding": null,
+                "CL {$level}": null,
+                "Availability": null,
+                "Reconstruction": null,
+                "References": null,
+                "Entertainment": null,
                 // sex practices
                 "Failed": null,
                 // diseases

package/lib/types/_ActivatableSkillApplicationsAndUses.js

@@ -36,6 +36,7 @@ export const NewSkillApplication = DB.Entity(import.meta.url, {
     }),
 });
 export const skill_applications = DB.Required({
+    displayName: "New Skill Applications",
     comment: "Registers new skill applications, which get enabled once this entry is activated. It specifies an entry-unique identifier and the skill it belongs to. A translation can be left out if its name equals the name of the origin activatable entry.",
     type: DB.ChildEntities(NewSkillApplication),
 });
@@ -73,6 +74,7 @@ export const SkillUse = DB.Entity(import.meta.url, {
     }),
 });
 export const skill_uses = DB.Required({
+    displayName: "Skill Uses",
     comment: "Registers uses, which get enabled once this entry is activated. It specifies an entry-unique identifier and the skill it belongs to. A translation can be left out if its name equals the name of the origin activatable entry.",
     type: DB.ChildEntities(SkillUse),
 });

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

@@ -88,6 +88,11 @@ export declare const Book: DB.Entity<"Book", {
     structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
         points: DB.MemberDecl<DB.Integer, true>;
     }>, []>>>, []>>, false>;
+    contentQuality: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BookContentQuality", {
+        Modest: DB.EnumCase<null>;
+        Average: DB.EnumCase<null>;
+        Demanding: DB.EnumCase<DB.Integer>;
+    }, []>>, 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, {
@@ -135,7 +140,27 @@ export declare const Book: DB.Entity<"Book", {
         language: DB.MemberDecl<DB.String, false>;
         script: DB.MemberDecl<DB.String, false>;
         note: DB.MemberDecl<DB.String, false>;
-        rules: DB.MemberDecl<DB.String, false>;
+        rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BookRules", {
+            Plain: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainBookRules", DB.Object<{
+                text: DB.MemberDecl<DB.String, true>;
+                reconstruction: DB.MemberDecl<DB.String, false>;
+                references: DB.MemberDecl<DB.String, false>;
+                textAfter: DB.MemberDecl<DB.String, false>;
+            }>, []>>>;
+            Entertainment: DB.EnumCase<null>;
+            ByEdition: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"BookRulesByEdition", DB.Object<{
+                editions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"BookRulesOfEdition", DB.Object<{
+                    label: DB.MemberDecl<DB.String, true>;
+                    text: DB.MemberDecl<DB.String, true>;
+                    reconstruction: DB.MemberDecl<DB.String, false>;
+                    references: DB.MemberDecl<DB.String, false>;
+                }>, []>>>, true>;
+                textAfter: DB.MemberDecl<DB.String, false>;
+            }>, []>>>;
+        }, []>>, false>;
+        legality: DB.MemberDecl<DB.String, false>;
+        availability: DB.MemberDecl<DB.String, false>;
+        special: 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>;

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

@@ -28,6 +28,10 @@ export const Book = DB.Entity(import.meta.url, {
             comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points.",
             type: DB.IncludeIdentifier(StructurePoints),
         }),
+        contentQuality: DB.Optional({
+            comment: "The quality of the book’s content.",
+            type: DB.IncludeIdentifier(BookContentQuality),
+        }),
         src,
         translations: NestedTranslationMap(DB.Required, "Book", DB.Object({
             name: DB.Required({
@@ -52,6 +56,18 @@ export const Book = DB.Entity(import.meta.url, {
             }),
             rules: DB.Optional({
                 comment: "Special rules text.",
+                type: DB.IncludeIdentifier(BookRules),
+            }),
+            legality: DB.Optional({
+                comment: "The legality of the item, if specified.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+            availability: DB.Optional({
+                comment: "The availability of the item, if specified.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+            special: DB.Optional({
+                comment: "Special properties or features of the item.",
                 type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
@@ -179,3 +195,77 @@ const IndefiniteBookCostVariant = DB.TypeAlias(import.meta.url, {
         })),
     }),
 });
+const BookContentQuality = DB.Enum(import.meta.url, {
+    name: "BookContentQuality",
+    comment: "The quality of the book’s content.",
+    values: () => ({
+        Modest: DB.EnumCase({ type: null }),
+        Average: DB.EnumCase({ type: null }),
+        Demanding: DB.EnumCase({ type: DB.Integer({ minimum: 1, maximum: 3 }) }),
+    }),
+});
+const BookRules = DB.Enum(import.meta.url, {
+    name: "BookRules",
+    comment: "Skills and abilities you can learn by reading the book, as well as any other rules and effects concerning the book.",
+    values: () => ({
+        Plain: DB.EnumCase({ type: DB.IncludeIdentifier(PlainBookRules) }),
+        Entertainment: DB.EnumCase({ type: null }),
+        ByEdition: DB.EnumCase({ type: DB.IncludeIdentifier(BookRulesByEdition) }),
+    }),
+});
+const PlainBookRules = DB.TypeAlias(import.meta.url, {
+    name: "PlainBookRules",
+    comment: "The book’s rules without any special effects or conditions.",
+    type: () => DB.Object({
+        text: DB.Required({
+            comment: "The (main) rules text.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        reconstruction: DB.Optional({
+            comment: "Rules for reconstructing certain skills or abilities from the book.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        references: DB.Optional({
+            comment: "References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        textAfter: DB.Optional({
+            comment: "Additional rules text that comes after all other rules.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+    }),
+});
+const BookRulesByEdition = DB.TypeAlias(import.meta.url, {
+    name: "BookRulesByEdition",
+    comment: "The book’s rules with differences between each edition and more differentiation between types of rules.",
+    type: () => DB.Object({
+        editions: DB.Required({
+            type: DB.Array(DB.IncludeIdentifier(BookRulesOfEdition), { minItems: 1 }),
+        }),
+        textAfter: DB.Optional({
+            comment: "Additional rules text that comes after all other rules.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+    }),
+});
+const BookRulesOfEdition = DB.TypeAlias(import.meta.url, {
+    name: "BookRulesOfEdition",
+    type: () => DB.Object({
+        label: DB.Required({
+            comment: "The edition(s) the rules apply to.",
+            type: DB.String({ minLength: 1 }),
+        }),
+        text: DB.Required({
+            comment: "The rules text.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        reconstruction: DB.Optional({
+            comment: "Rules for reconstructing certain skills or abilities from the book.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        references: DB.Optional({
+            comment: "References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+    }),
+});

package/package.json

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