optolith-database-schema 0.34.13 → 0.34.15

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 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.34.15](https://github.com/elyukai/optolith-database-schema/compare/v0.34.14...v0.34.15) (2026-03-12)
+
+
+### Features
+
+* add translations for recent additions ([8f59744](https://github.com/elyukai/optolith-database-schema/commit/8f59744409c12894525e18b880296cefc9e90aa1))
+
+## [0.34.14](https://github.com/elyukai/optolith-database-schema/compare/v0.34.13...v0.34.14) (2026-03-11)
+
 ## [0.34.13](https://github.com/elyukai/optolith-database-schema/compare/v0.34.12...v0.34.13) (2026-03-11)
 
 

package/gen/types.d.ts

@@ -2377,6 +2377,10 @@ export interface Locale {
     "Structure Points": string
     ".input {$value :number} {{{$value} Structure Points}}": string & { __params: { "value": number } }
     "{$value} Structure Points": string & { __params: { "value": StringableTranslationParameter } }
+    "Components": string
+    "Use": string
+    "purchase": string
+    "sale": string
     "{$types} poison": string & { __params: { "types": StringableTranslationParameter } }
     "Weapon (poison)": string
     "Ingestion (poison)": string
@@ -2419,6 +2423,7 @@ export interface Locale {
     ".input {$count :number} {{check required every {$count}. application}}": string & { __params: { "count": number } }
     ".input {$count :number} {{check required every {$count}. application in the same month}}": string & { __params: { "count": number } }
     "see {$link}": string & { __params: { "link": StringableTranslationParameter } }
+    "CoD": string
     "Failed": string
     "Progress": string
     "Incubation Time": string

package/lib/types/Blessing.js

@@ -25,7 +25,7 @@ export const Blessing = DB.Entity(import.meta.url, {
             }),
             effect: DB.Required({
                 comment: "The effect description.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             range: DB.Required({
                 isDeprecated: true,

package/lib/types/Cantrip.js

@@ -36,7 +36,7 @@ export const Cantrip = DB.Entity(import.meta.url, {
             }),
             effect: DB.Required({
                 comment: "The effect description.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             range: DB.Required({
                 isDeprecated: true,

package/lib/types/CombatTechnique.js

@@ -32,7 +32,7 @@ export const CloseCombatTechnique = DB.Entity(import.meta.url, {
             }),
             special: DB.Optional({
                 comment: "Additional rules for the combat technique, if applicable.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),
@@ -109,7 +109,7 @@ export const RangedCombatTechnique = DB.Entity(import.meta.url, {
             }),
             special: DB.Optional({
                 comment: "Additional rules for the combat technique, if applicable.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

package/lib/types/Condition.js

@@ -14,11 +14,11 @@ export const Condition = DB.Entity(import.meta.url, {
             }),
             rules: DB.Optional({
                 comment: "Additional rules for the condition, if applicable.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             effects: DB.Required({
                 comment: "The effects for level 1 to 4.",
-                type: DB.Array(DB.String({ minLength: 1, isMarkdown: true }), {
+                type: DB.Array(DB.String({ minLength: 1, markdown: "block" }), {
                     minItems: 4,
                     maxItems: 4,
                 }),

package/lib/types/DerivedCharacteristic.js

@@ -33,7 +33,7 @@ export const DerivedCharacteristic = DB.Entity(import.meta.url, {
             }),
             description: DB.Optional({
                 comment: "The derived characteristic’s description.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             calculation: DB.Optional({
                 comment: "Possible calculation strings for the final value.",

package/lib/types/Disadvantage.js

@@ -39,7 +39,7 @@ export const Disadvantage = DB.Entity(import.meta.url, {
             rules,
             range: DB.Optional({
                 comment: "The range.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             ap_value_append,
             ap_value: ap_value_l10n,

package/lib/types/FamiliarsTrick.js

@@ -39,7 +39,7 @@ If no animal types are given, the animal disease applies to all animal types.`,
             }),
             effect: DB.Required({
                 comment: "The effect description.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             cost: DB.Optional({
                 isDeprecated: true,

package/lib/types/Influence.js

@@ -18,7 +18,7 @@ export const Influence = DB.Entity(import.meta.url, {
             }),
             rules: DB.Optional({
                 comment: "Some general rules for the influence. They will be prepended to the effects. This can be used for influences that do not have any effects and should contain the text mentioning this fact.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             effects: DB.Optional({
                 comment: "The effects of the influence. They should be sorted like they are in the book.",
@@ -46,7 +46,7 @@ const InfluenceEffect = DB.TypeAlias(import.meta.url, {
         }),
         text: DB.Required({
             comment: "The effect text.",
-            type: DB.String({ minLength: 1, isMarkdown: true }),
+            type: DB.String({ minLength: 1, markdown: "block" }),
         }),
     }),
 });

package/lib/types/Locale.d.ts

@@ -1421,6 +1421,10 @@ export declare const Locale: DB.Entity<"Locale", {
         "Structure Points": null;
         ".input {$value :number} {{{$value} Structure Points}}": null;
         "{$value} Structure Points": null;
+        Components: null;
+        Use: null;
+        purchase: null;
+        sale: null;
         "{$types} poison": null;
         "Weapon (poison)": null;
         "Ingestion (poison)": null;
@@ -1463,6 +1467,7 @@ export declare const Locale: DB.Entity<"Locale", {
         ".input {$count :number} {{check required every {$count}. application}}": null;
         ".input {$count :number} {{check required every {$count}. application in the same month}}": null;
         "see {$link}": null;
+        CoD: null;
         Failed: null;
         Progress: null;
         "Incubation Time": null;

package/lib/types/Locale.js

@@ -1461,6 +1461,10 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Structure Points": null,
                 ".input {$value :number} {{{$value} Structure Points}}": null,
                 "{$value} Structure Points": null,
+                "Components": null,
+                "Use": null,
+                "purchase": null,
+                "sale": null,
                 // poisons/elixirs
                 "{$types} poison": null,
                 "Weapon (poison)": null,
@@ -1504,6 +1508,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 ".input {$count :number} {{check required every {$count}. application}}": null,
                 ".input {$count :number} {{check required every {$count}. application in the same month}}": null,
                 "see {$link}": null,
+                "CoD": null,
                 // sex practices
                 "Failed": null,
                 // diseases

package/lib/types/MetaCondition.js

@@ -15,11 +15,11 @@ export const MetaCondition = DB.Entity(import.meta.url, {
             }),
             rules: DB.Optional({
                 comment: "Additional rules for the meta condition, if applicable.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             effects: DB.Required({
                 comment: "The effects for level 1 to 4.",
-                type: DB.Array(DB.String({ minLength: 1, isMarkdown: true }), {
+                type: DB.Array(DB.String({ minLength: 1, markdown: "block" }), {
                     minItems: 4,
                     maxItems: 4,
                 }),

package/lib/types/Service.js

@@ -21,7 +21,7 @@ export const Service = DB.Entity(import.meta.url, {
             }),
             description: DB.Required({
                 comment: "The service’s description.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

package/lib/types/State.js

@@ -14,7 +14,7 @@ export const State = DB.Entity(import.meta.url, {
             }),
             description: DB.Required({
                 comment: "The description of the state.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

package/lib/types/Talisman.js

@@ -57,7 +57,7 @@ export const Talisman = DB.Entity(import.meta.url, {
             }),
             effect: DB.Required({
                 comment: "The effect description.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             activation: DB.Optional({
                 comment: "The activation parameters.",

package/lib/types/_Activatable.js

@@ -26,11 +26,11 @@ The maximum is only set if it differs from the defaults specified above.`,
 });
 export const rules = DB.Required({
     comment: "The rule text.",
-    type: DB.String({ minLength: 1, isMarkdown: true }),
+    type: DB.String({ minLength: 1, markdown: "block" }),
 });
 export const effect = DB.Required({
     comment: "The effect description.",
-    type: DB.String({ minLength: 1, isMarkdown: true }),
+    type: DB.String({ minLength: 1, markdown: "block" }),
 });
 export const range_l10n = DB.Optional({
     comment: "The range of the advantage.",

package/lib/types/_ActivatableAdventurePointsValue.js

@@ -67,7 +67,7 @@ const AdventurePointsDerivedFromSelection = DB.TypeAlias(import.meta.url, {
             }),
             replacement: DB.Optional({
                 comment: "A replacement for the generated text if it would not match the original one.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
         }, { minProperties: 1 })),
     }),

package/lib/types/_ActivatableNonMundane.js

@@ -505,7 +505,7 @@ const BindingCostDerivedFromSelection = DB.TypeAlias(import.meta.url, {
             }),
             replacement: DB.Optional({
                 comment: "A replacement for the generated text if it would not match the original one.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
         }, { minProperties: 1 })),
     }),

package/lib/types/_ActivatableSelectOptions.js

@@ -68,7 +68,7 @@ export const GeneralSelectOption = DB.Entity(import.meta.url, {
             }),
             description: DB.Optional({
                 comment: "The description of the select option. Useful for Bad Habits, Trade Secrets and other entries where a description is available.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

package/lib/types/_ActivatableSkillEffect.js

@@ -19,7 +19,7 @@ const ActivatableSkillPlainEffect = DB.TypeAlias(import.meta.url, {
     type: () => DB.Object({
         text: DB.Required({
             comment: "The effect description.",
-            type: DB.String({ minLength: 1, isMarkdown: true }),
+            type: DB.String({ minLength: 1, markdown: "block" }),
         }),
     }),
 });
@@ -28,18 +28,18 @@ const ActivatableSkillEffectForEachQualityLevel = DB.TypeAlias(import.meta.url,
     type: () => DB.Object({
         text_before: DB.Required({
             comment: "The effect description before the list of effects for each quality level.",
-            type: DB.String({ minLength: 1, isMarkdown: true }),
+            type: DB.String({ minLength: 1, markdown: "block" }),
         }),
         quality_levels: DB.Required({
             comment: "The list of effects 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, isMarkdown: true }), {
+            type: DB.Array(DB.String({ minLength: 1, markdown: "block" }), {
                 minItems: 6,
                 maxItems: 6,
             }),
         }),
         text_after: DB.Optional({
             comment: "The effect description after the list of effects for each quality level.",
-            type: DB.String({ minLength: 1, isMarkdown: true }),
+            type: DB.String({ minLength: 1, markdown: "block" }),
         }),
     }),
 });
@@ -48,18 +48,18 @@ const ActivatableSkillEffectForEachTwoQualityLevels = DB.TypeAlias(import.meta.u
     type: () => DB.Object({
         text_before: DB.Required({
             comment: "The effect description before the list of effects for each quality level.",
-            type: DB.String({ minLength: 1, isMarkdown: true }),
+            type: DB.String({ minLength: 1, markdown: "block" }),
         }),
         quality_levels: DB.Required({
             comment: "The list of effects for each two quality levels. The first element represents QL 1–2, the second element QL 3–4 and the third element QL 5–6.",
-            type: DB.Array(DB.String({ minLength: 1, isMarkdown: true }), {
+            type: DB.Array(DB.String({ minLength: 1, markdown: "block" }), {
                 minItems: 3,
                 maxItems: 3,
             }),
         }),
         text_after: DB.Optional({
             comment: "The effect description after the list of effects for each quality level.",
-            type: DB.String({ minLength: 1, isMarkdown: true }),
+            type: DB.String({ minLength: 1, markdown: "block" }),
         }),
     }),
 });

package/lib/types/_DiseasePoison.js

@@ -78,7 +78,7 @@ export const DiseaseTranslation = DB.Object({
     }),
     progress: DB.Required({
         comment: "The disease’s progress, in detail.",
-        type: DB.String({ minLength: 1, isMarkdown: true }),
+        type: DB.String({ minLength: 1, markdown: "block" }),
     }),
     incubation_time: DB.Required({
         comment: "After infection, how much time passes before symptoms appear?",
@@ -86,23 +86,23 @@ export const DiseaseTranslation = DB.Object({
     }),
     damage: DB.Required({
         comment: "The damage caused by the disease. If the disease check fails, apply the lessened effects.",
-        type: DB.GenIncludeIdentifier(Reduceable, [DB.String({ minLength: 1, isMarkdown: true })]),
+        type: DB.GenIncludeIdentifier(Reduceable, [DB.String({ minLength: 1, markdown: "block" })]),
     }),
     duration: DB.Required({
         comment: "The duration of the disease. If the disease check fails, use the lessened duration.",
-        type: DB.GenIncludeIdentifier(Reduceable, [DB.String({ minLength: 1, isMarkdown: true })]),
+        type: DB.GenIncludeIdentifier(Reduceable, [DB.String({ minLength: 1, markdown: "block" })]),
     }),
     special: DB.Optional({
         comment: "Special information about the disease.",
-        type: DB.String({ minLength: 1, isMarkdown: true }),
+        type: DB.String({ minLength: 1, markdown: "block" }),
     }),
     treatment: DB.Required({
         comment: "Methods known to lessen the disease’s progress or relieve symptoms.",
-        type: DB.String({ minLength: 1, isMarkdown: true }),
+        type: DB.String({ minLength: 1, markdown: "block" }),
     }),
     cure: DB.Required({
         comment: "Known remedies for the disease.",
-        type: DB.String({ minLength: 1, isMarkdown: true }),
+        type: DB.String({ minLength: 1, markdown: "block" }),
     }),
     errata: DB.Optional({
         type: DB.IncludeIdentifier(Errata),

package/lib/types/_Enhancements.js

@@ -52,7 +52,7 @@ export const Enhancement = DB.Entity(import.meta.url, {
                 comment: "The effect description.",
                 type: DB.String({
                     minLength: 1,
-                    isMarkdown: true,
+                    markdown: "block",
                 }),
             }),
             errata: DB.Optional({

package/lib/types/_Spellwork.js

@@ -32,7 +32,7 @@ const ReversalisEffect = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Required, "ReversalisEffect", DB.Object({
             effect: DB.Required({
                 comment: "The effect description of the reversed spell.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         })),
     }),

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

@@ -23,11 +23,11 @@ export const Ammunition = DB.Entity(import.meta.url, {
             }),
             note: DB.Optional({
                 comment: "Note text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             rules: DB.Optional({
                 comment: "Special rules text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

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

@@ -56,19 +56,19 @@ export const Armor = DB.Entity(import.meta.url, {
             }),
             note: DB.Optional({
                 comment: "Note text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             rules: DB.Optional({
                 comment: "Special rules text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             advantage: DB.Optional({
                 comment: "The armor advantage text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             disadvantage: DB.Optional({
                 comment: "The armor disadvantage text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),
@@ -113,11 +113,11 @@ export const SecondaryArmor = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Optional, "SecondaryArmor", DB.Object({
             advantage: DB.Optional({
                 comment: "The armor advantage text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             disadvantage: DB.Optional({
                 comment: "The armor disadvantage text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         }, { minProperties: 1 })),
     }),

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

@@ -40,19 +40,19 @@ export const Book = DB.Entity(import.meta.url, {
             }),
             language: DB.Optional({
                 comment: "The language the book is written in, if specified.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             script: DB.Optional({
                 comment: "The script that was used for the book, if specified.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             note: DB.Optional({
                 comment: "Note text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             rules: DB.Optional({
                 comment: "Special rules text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),
@@ -158,7 +158,7 @@ const DefiniteBookCostVariant = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Optional, "DefiniteBookCostVariant", DB.Object({
             label: DB.Optional({
                 comment: "The label for the cost variant, e.g. “Original script”.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
         }, { minProperties: 1 })),
     }),
@@ -170,11 +170,11 @@ const IndefiniteBookCostVariant = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Required, "IndefiniteBookCostVariant", DB.Object({
             label: DB.Optional({
                 comment: "The label for the cost variant, e.g. “Original script”.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             description: DB.Required({
                 comment: "The description of the cost variant, e.g. “less”.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         })),
     }),

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

@@ -56,11 +56,11 @@ export const Elixir = DB.Entity(import.meta.url, {
             }),
             brewing_process_prerequisites: DB.Optional({
                 comment: "Prerequsites for the brewing process, if any.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             quality_levels: DB.Required({
                 comment: "The list of effects 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, isMarkdown: true }), {
+                type: DB.Array(DB.String({ minLength: 1, markdown: "block" }), {
                     minItems: 6,
                     maxItems: 6,
                 }),

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

@@ -31,11 +31,11 @@ export const GemOrPreciousStone = DB.Entity(import.meta.url, {
             }),
             note: DB.Optional({
                 comment: "Note text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             rules: DB.Optional({
                 comment: "Special rules text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

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

@@ -40,23 +40,23 @@ export const MagicalArtifact = DB.Entity(import.meta.url, {
             }),
             description: DB.Optional({
                 comment: "Description text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             note: DB.Optional({
                 comment: "A note.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             rules: DB.Optional({
                 comment: "Rules text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             effect: DB.Optional({
                 comment: "Effect text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             cost: DB.Optional({
                 comment: "Cost text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

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

@@ -56,12 +56,12 @@ export const Poison = DB.Entity(import.meta.url, {
             effect: DB.Required({
                 comment: "The normal and degraded poison’s effects.",
                 type: DB.GenIncludeIdentifier(Reduceable, [
-                    DB.String({ minLength: 1, isMarkdown: true }),
+                    DB.String({ minLength: 1, markdown: "block" }),
                 ]),
             }),
             notes: DB.Optional({
                 comment: "Notes on the poison’s special features.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),
@@ -123,7 +123,7 @@ export const NoPoisonCost = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Optional, "NoPoisonCost", DB.Object({
             description: DB.Required({
                 comment: "A description of the cost.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         })),
     }),
@@ -134,7 +134,7 @@ export const IndefinitePoisonCost = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Required, "IndefinitePoisonCost", DB.Object({
             description: DB.Required({
                 comment: "A description of the cost.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         })),
     }),
@@ -219,7 +219,7 @@ export const IndefinitePoisonTime = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Optional, "IndefinitePoisonTime", DB.Object({
             description: DB.Optional({
                 comment: "A description of the duration.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         }, { minProperties: 1 })),
     }),
@@ -317,7 +317,7 @@ export const AlchemicalPoison = DB.TypeAlias(import.meta.url, {
             }),
             brewing_process_prerequisites: DB.Optional({
                 comment: "Prerequsites for the brewing process, if any.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         })),
     }),
@@ -358,7 +358,7 @@ export const DemonicPoison = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Optional, "DemonicPoison", DB.Object({
             note: DB.Optional({
                 comment: "A note, if any.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         }, { minProperties: 1 })),
     }),
@@ -407,19 +407,19 @@ export const Intoxicant = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Required, "Intoxicant", DB.Object({
             ingestion: DB.Required({
                 comment: "How to ingest the intoxicant.",
-                type: DB.String({ minLength: 1 }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             side_effect: DB.Optional({
                 comment: "The intoxicants side effects that always happen, no matter whether the intoxicant has the default or the reduced effect.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             overdose: DB.Optional({
                 comment: "What happens if the intoxicant has been overdosed, that is, it has been ingested another time within the duration.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             special: DB.Optional({
                 comment: "Special information about the intoxicant.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         })),
     }),
@@ -456,7 +456,7 @@ export const IntoxicantAddiction = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Optional, "IntoxicantAddiction", DB.Object({
             chance: DB.Required({
                 comment: "The chance of getting addicted after an ingestion. Use if and only if the plain constant percent is not sufficient.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
         })),
     }),

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

@@ -63,19 +63,19 @@ export const Weapon = DB.Entity(import.meta.url, {
             }),
             note: DB.Optional({
                 comment: "Note text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             rules: DB.Optional({
                 comment: "Special rules text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             advantage: DB.Optional({
                 comment: "The weapon advantage text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             disadvantage: DB.Optional({
                 comment: "The weapon disadvantage text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),
@@ -121,11 +121,11 @@ export const ImprovisedWeapon = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Optional, "ImprovisedWeapon", DB.Object({
             advantage: DB.Optional({
                 comment: "The weapon advantage text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             disadvantage: DB.Optional({
                 comment: "The weapon disadvantage text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         }, { minProperties: 1 })),
     }),

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

@@ -63,11 +63,11 @@ export const DefaultItemTranslations = (singularName) => NestedTranslationMap(DB
     }),
     note: DB.Optional({
         comment: "Note text.",
-        type: DB.String({ minLength: 1, isMarkdown: true }),
+        type: DB.String({ minLength: 1, markdown: "block" }),
     }),
     rules: DB.Optional({
         comment: "Special rules text.",
-        type: DB.String({ minLength: 1, isMarkdown: true }),
+        type: DB.String({ minLength: 1, markdown: "block" }),
     }),
     errata: DB.Optional({
         type: DB.IncludeIdentifier(Errata),

package/lib/types/magicalActions/AnimistPower.js

@@ -95,7 +95,7 @@ const AnimistPowerLevel = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Required, "AnimistPowerLevel", DB.Object({
             effect: DB.Required({
                 comment: "An additional effect description for this level.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         })),
     }),

package/lib/types/prerequisites/single/TextPrerequisite.js

@@ -25,7 +25,7 @@ This is the only use case for this property.`,
         translations: NestedTranslationMap(DB.Required, "TextPrerequisite", DB.Object({
             text: DB.Required({
                 comment: "The displayed text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
         })),
     }),

package/lib/types/rule/AlternativeRule.js

@@ -23,7 +23,7 @@ export const AlternativeRule = DB.Entity(import.meta.url, {
             }),
             description: DB.Required({
                 comment: "The description of the alternative rule.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

package/lib/types/rule/CoreRule.js

@@ -60,7 +60,7 @@ const TextNode = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Required, "TextNode", DB.Object({
             text: DB.Required({
                 comment: "Markdown-formatted text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         })),
     }),
@@ -75,7 +75,7 @@ const ReferenceListNode = DB.TypeAlias(import.meta.url, {
         translations: NestedTranslationMap(DB.Required, "ReferenceListNode", DB.Object({
             text: DB.Required({
                 comment: "Markdown-formatted text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
         })),
     }),

package/lib/types/rule/FocusRule.js

@@ -31,7 +31,7 @@ export const FocusRule = DB.Entity(import.meta.url, {
             }),
             description: DB.Required({
                 comment: "The description of the focus rule.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

package/lib/types/rule/OptionalRule.js

@@ -26,11 +26,11 @@ export const OptionalRule = DB.Entity(import.meta.url, {
             }),
             description: DB.Required({
                 comment: "The description of the optional rule, as stated in the optional rule box.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             additionalRules: DB.Optional({
                 comment: "Sometimes, an optional rule does not only contain all the rules belonging to it in its rule box, but also in the main text.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

package/lib/types/specialAbility/MagicalTradition.js

@@ -82,7 +82,7 @@ export const MagicalTradition = DB.Entity(import.meta.url, {
             }),
             supplemental_content: DB.Optional({
                 comment: "Supplemental content for the tradition, such as additional information or clarifications.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             ap_value_append,
             ap_value: ap_value_l10n,

package/lib/types/specialAbility/ProtectiveWardingCircleSpecialAbility.js

@@ -30,11 +30,11 @@ export const ProtectiveWardingCircleSpecialAbility = DB.Entity(import.meta.url,
             name_in_library,
             protective_circle: DB.Required({
                 comment: "The rules for the protective circle variant.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             warding_circle: DB.Optional({
                 comment: "The rules for the warding circle variant.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             ap_value_append,
             ap_value: ap_value_l10n,

package/lib/types/specialAbility/sub/TradeSecret.js

@@ -38,7 +38,7 @@ export const TradeSecret = DB.Entity(import.meta.url, {
             name_in_library,
             description: DB.Optional({
                 comment: "The description of the trade secret.",
-                type: DB.String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, markdown: "block" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optolith-database-schema",
-  "version": "0.34.13",
+  "version": "0.34.15",
   "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",
@@ -39,7 +39,7 @@
   "license": "MPL-2.0",
   "dependencies": {
     "@elyukai/utils": "^0.3.0",
-    "tsondb": "^0.19.18",
+    "tsondb": "^0.20.0",
     "yaml": "^2.8.2"
   },
   "devDependencies": {