optolith-database-schema 0.36.1 → 0.37.0

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 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.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/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[]
+
+  /**
+   * 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
+}
+
+export interface BookRulesOfEdition {
+  /**
+   * The edition(s) the rules apply to.
+   */
+  label: string
+
+  /**
+   * The rules text.
+   */
+  text: 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/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>;
+                }>, []>>>, true>;
+                reconstruction: DB.MemberDecl<DB.String, false>;
+                references: DB.MemberDecl<DB.String, false>;
+                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 }),
+        }),
+        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 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" }),
+        }),
+    }),
+});

package/package.json

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