@optolith/database-schema 0.89.0 → 0.91.0

package/lib/cache/activatableSelectOptions.js

@@ -46,13 +46,6 @@ const getSkillishPrerequisites = (ps, id) => {
         }
     });
 };
-const getSkillishBindingCost = (bindingCost, id) => {
-    if (bindingCost === undefined) {
-        return undefined;
-    }
-    return (bindingCost.Fixed.map.find(mapping => equalsSkillishIdGroup(mapping.id, id))?.bindingCost ??
-        bindingCost.Fixed.default);
-};
 const equalsSkillishIdGroup = (a, b) => {
     switch (a.kind) {
         case "Skill":
@@ -73,6 +66,13 @@ const equalsSkillishIdGroup = (a, b) => {
             return assertExhaustive(a);
     }
 };
+const getSkillishBindingCost = (bindingCost, id) => {
+    if (bindingCost === undefined) {
+        return undefined;
+    }
+    return (bindingCost.Fixed.map.find(mapping => equalsSkillishIdGroup(mapping.id, id))?.bindingCost ??
+        bindingCost.Fixed.default);
+};
 const getApValueForSkillish = (config, id, ic) => {
     if (config === undefined) {
         return undefined;
@@ -103,7 +103,7 @@ const getApValueForSkillish = (config, id, ic) => {
     }
 };
 const convertSkillApplicationOrUse = (entryId, id, applicationOrUse) => ({
-    id: fromUniformCase(entryId) + "+" + applicationOrUse.id,
+    id: `${fromUniformCase(entryId)}+${applicationOrUse.id.toFixed()}`,
     content: {
         parent: entryId,
         skills: [id],
@@ -223,13 +223,13 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
             const animalShapePaths = database.getAllInstanceContainersOfEntity("AnimalShapePath");
             const animalShapeSizes = database.getAllInstanceContainersOfEntity("AnimalShapeSize");
             const animalShapes = database.getAllInstanceContainersOfEntity("AnimalShape");
-            const pathsWithOrderedIds = animalShapePaths.reduce((acc, { id }) => ({
-                ...acc,
-                [id]: animalShapes
+            const pathsWithOrderedIds = animalShapePaths.reduce((acc, { id }) => {
+                acc[id] = animalShapes
                     .toSorted(on(item => database.getInstanceContainerOfEntityById("AnimalShapeSize", item.content.size)
                     ?.content.volume, compareNullish(compareNumber)))
-                    .map(({ id }) => id),
-            }), {});
+                    .map(({ id: shapeId }) => shapeId);
+                return acc;
+            }, {});
             return animalShapes.map(({ id, content }) => {
                 const path = animalShapePaths.find(({ id: pathId }) => pathId === content.path);
                 const size = animalShapeSizes.find(({ id: sizeId }) => sizeId === content.size);
@@ -247,6 +247,7 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
                                     prerequisite: Case("Single", Case("Activatable", {
                                         id: entryId,
                                         active: false,
+                                        // oxlint-disable-next-line typescript/no-non-null-assertion
                                         options: [Case("AnimalShape", pathsWithOrderedIds[pathId][0])],
                                     })),
                                 }))
@@ -257,6 +258,7 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
                                             id: entryId,
                                             active: true,
                                             options: [
+                                                // oxlint-disable-next-line typescript/no-non-null-assertion
                                                 Case("AnimalShape", pathsWithOrderedIds[path.id][pathIndex - 1]),
                                             ],
                                         })),
@@ -404,7 +406,7 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
             }));
         case "BlessedTraditions": {
             const getPrerequisites = (blessedTradition) => {
-                if (selectOptionCategory.BlessedTraditions.require_principles &&
+                if (selectOptionCategory.BlessedTraditions.require_principles === true &&
                     blessedTradition.associated_principles_id !== undefined) {
                     const option = database.getInstanceContainerOfEntityById("GeneralSelectOption", blessedTradition.associated_principles_id);
                     if (option === undefined || option.content.parent.kind === "TradeSecret") {
@@ -454,7 +456,7 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
                 newApplications: [],
                 uses: [],
             });
-            const specific = selectOptionCategory.Elements.specific;
+            const { specific } = selectOptionCategory.Elements;
             if (specific) {
                 return database
                     .getAllInstanceContainersOfEntity("Element")
@@ -720,8 +722,8 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
                 newApplications: [],
                 uses: [],
             });
-            const list = selectOptionCategory.TargetCategories.list;
-            if (list) {
+            const { list } = selectOptionCategory.TargetCategories;
+            if (list.length > 0) {
                 return database
                     .getAllInstanceContainersOfEntity("TargetCategory")
                     .filter(({ id }) => list.some(ref => ref.id === id))
@@ -737,8 +739,8 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
 };
 const getExplicitSelectOptions = (id, database) => database
     .getAllChildInstanceContainersForParent("GeneralSelectOption", id)
-    .map(({ id, content }) => ({
-    id: Case("General", id),
+    .map(({ id: optionid, content }) => ({
+    id: Case("General", optionid),
     content: {
         ...content,
         ap_value: wrapPlainApValue(content.ap_value),

package/lib/cache/ancestorBloodAdvantages.js

@@ -1,3 +1,4 @@
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
 export const buildAncestorBloodAdvantagesCache = database => database
     .getAllInstanceContainersOfEntity("Advantage")
     .filter(({ content }) => content.prerequisites?.some(p => {
@@ -8,6 +9,8 @@ export const buildAncestorBloodAdvantagesCache = database => database
             return p.prerequisite.Disjunction.list.some(d => d.kind === "NoOtherAncestorBloodAdvantage");
         case "Group":
             return p.prerequisite.Group.list.some(g => g.kind === "NoOtherAncestorBloodAdvantage");
+        default:
+            return assertExhaustive(p.prerequisite);
     }
-}))
+}) ?? false)
     .map(({ id }) => id);

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.js

@@ -69,19 +69,18 @@ const is = (settings, type, entry, getById, traversedIds) => {
         return false;
     }
     const newTraversedIds = [...traversedIds, entry.id];
-    return (entry.content.prerequisites !== undefined &&
-        entry.content.prerequisites.some(prerequisite => {
-            switch (prerequisite.prerequisite.kind) {
-                case "Single":
-                    return isPrerequisiteFor(settings, type, prerequisite.prerequisite.Single, getById, newTraversedIds);
-                case "Disjunction":
-                    return prerequisite.prerequisite.Disjunction.list.some(p => isPrerequisiteFor(settings, type, p, getById, newTraversedIds));
-                case "Group":
-                    return prerequisite.prerequisite.Group.list.some(p => isPrerequisiteFor(settings, type, p, getById, newTraversedIds));
-                default:
-                    return assertExhaustive(prerequisite.prerequisite);
-            }
-        }));
+    return entry.content.prerequisites.some(prerequisite => {
+        switch (prerequisite.prerequisite.kind) {
+            case "Single":
+                return isPrerequisiteFor(settings, type, prerequisite.prerequisite.Single, getById, newTraversedIds);
+            case "Disjunction":
+                return prerequisite.prerequisite.Disjunction.list.some(p => isPrerequisiteFor(settings, type, p, getById, newTraversedIds));
+            case "Group":
+                return prerequisite.prerequisite.Group.list.some(p => isPrerequisiteFor(settings, type, p, getById, newTraversedIds));
+            default:
+                return assertExhaustive(prerequisite.prerequisite);
+        }
+    });
 };
 const entityKeyMap = {
     Advantage: null,
@@ -95,12 +94,12 @@ const collectIds = (entity, type, database, settings) => database
     .getAllInstanceContainersOfEntity(entity)
     .filter(entry => is(settings, type, entry, database.getInstanceContainerOfEntityById.bind(database), []))
     .map(({ id }) => id);
-export const buildMagicalAndBlessedAdvantagesAndDisadvantagesCache = (database, settings) => {
-    return Object.fromEntries(Object.keys(entityKeyMap).map((entity) => [
-        entity,
-        Object.fromEntries(Object.keys(typeKeyMap).map((type) => [
-            type,
-            collectIds(entity, type, database, settings),
-        ])),
-    ]));
-};
+export const buildMagicalAndBlessedAdvantagesAndDisadvantagesCache = (database, settings) => Object.fromEntries(Object.keys(entityKeyMap).map((entity) => [
+    entity,
+    Object.fromEntries(Object.keys(typeKeyMap).map(
+    // oxlint-disable-next-line typescript/no-duplicate-type-constituents
+    (type) => [
+        type,
+        collectIds(entity, type, database, settings),
+    ])),
+]));

package/lib/cache/newApplicationsAndUses.js

@@ -1,4 +1,7 @@
-const groupByAffectedSkill = (entries, prev = {}) => entries.reduce((acc, entry) => entry.content.skills.reduce((acc1, skillId) => ({ ...acc1, [skillId]: [...(acc1[skillId] ?? []), entry] }), acc), prev);
+const groupByAffectedSkill = (entries, prev = {}) => entries.reduce((acc, entry) => entry.content.skills.reduce((acc1, skillId) => {
+    acc1[skillId] = [...(acc1[skillId] ?? []), entry];
+    return acc1;
+}, acc), prev);
 const addGeneratedEntries = (generatedSelectOptions, prev) => Object.values(generatedSelectOptions).reduce((acc, byInstance) => Object.values(byInstance).reduce((acc1, resolvedSelectOptions) => resolvedSelectOptions.reduce((acc2, selectOption) => ({
     newApplications: groupByAffectedSkill(selectOption.newApplications, acc2.newApplications),
     uses: groupByAffectedSkill(selectOption.uses, acc2.uses),

package/lib/cache/tradeSecrets.js

@@ -113,7 +113,7 @@ export const buildDerivedTradeSecretsCache = (database, settings) => {
                     if (container.content.source_type.kind === "AlchemicalPoison") {
                         addTradeSecretToHerbaryCache(entity, container, container.content.source_type.AlchemicalPoison.trade_secret);
                     }
-                    else if (container.content.source_type.kind == "AnimalVenom" &&
+                    else if (container.content.source_type.kind === "AnimalVenom" &&
                         container.content.source_type.AnimalVenom.complexity?.kind === "Complex") {
                         addTradeSecretToHerbaryCache(entity, container, container.content.source_type.AnimalVenom.complexity.Complex);
                     }

package/lib/test.js

@@ -1,3 +1,4 @@
+// oxlint-disable no-undef
 import { stderr } from "node:process";
 import { styleText } from "node:util";
 // importing the main file will run the schema checks

package/lib/types/AnimalDisease.js

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { cause, Cause, DiseaseTranslation, level, resistance } from "./_DiseasePoison.js";
 import { AnimalTypeIdentifier } from "./_Identifier.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { src } from "./source/_PublicationRef.js";
 export const AnimalDisease = DB.Entity(import.meta.url, {
     name: "AnimalDisease",

package/lib/types/Attribute.js

@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { AttributeColor } from "./_Color.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const Attribute = DB.Entity(import.meta.url, {
     name: "Attribute",
     namePlural: "Attributes",

package/lib/types/Culture.d.ts

@@ -54,7 +54,8 @@ export declare const Culture: DB.Entity<"Culture", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -91,7 +92,8 @@ export declare const Culture: DB.Entity<"Culture", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -128,7 +130,8 @@ export declare const Culture: DB.Entity<"Culture", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -165,7 +168,8 @@ export declare const Culture: DB.Entity<"Culture", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;

package/lib/types/DerivedCharacteristic.js

@@ -1,11 +1,11 @@
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import * as DB from "tsondb/schema/dsl";
 import { fromUniformCase } from "tsondb/schema/gen";
-import { NestedTranslationMap } from "./Locale.js";
 import { AttributeIdentifier } from "./_Identifier.js";
 import { ImprovementCost } from "./_ImprovementCost.js";
 import { MathOperation } from "./_MathExpression.js";
 import { DerivedCharacteristicPrerequisites } from "./_Prerequisite.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { DerivedCharacteristicModifierPrerequisiteGroup } from "./prerequisites/PrerequisiteGroups.js";
 import { src } from "./source/_PublicationRef.js";
 export const DerivedCharacteristic = DB.Entity(import.meta.url, {
@@ -155,6 +155,8 @@ export const calculationContainsRaceBase = (base) => {
             const [left, right] = fromUniformCase(base);
             return calculationContainsRaceBase(left) || calculationContainsRaceBase(right);
         }
+        default:
+            return assertExhaustive(base);
     }
 };
 const DerivedCharacteristicModifierOperation = DB.Enum(import.meta.url, {

package/lib/types/Disease.js

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { cause, DiseaseTranslation, level, resistance } from "./_DiseasePoison.js";
 import { RecipeTradeSecret } from "./equipment/item/_Herbary.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { src } from "./source/_PublicationRef.js";
 export const Disease = DB.Entity(import.meta.url, {
     name: "Disease",

package/lib/types/Lessons.js

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { CurriculumIdentifier, ElementIdentifier, GuidelineIdentifier, MagicalTraditionIdentifier, PropertyIdentifier, SkillIdentifier, } from "./_Identifier.js";
 import { CombatTechniqueIdentifier, SpellworkIdentifier } from "./_IdentifierGroup.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
 import { src } from "./source/_PublicationRef.js";
 export const Guideline = DB.Entity(import.meta.url, {

package/lib/types/Locale.js

@@ -21,6 +21,7 @@ export const Locale = DB.Entity(import.meta.url, {
             type: DB.IncludeIdentifier(LocaleMeasurementAdjustments),
         }),
         translations: DB.Optional({
+            // oxlint-disable-next-line no-warning-comments
             // TODO: Make Required again once translations are added for all locales
             comment: "The translations strings for the locale.",
             // prettier-ignore

package/lib/types/PatronCategory.js

@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { CultureIdentifier } from "./_Identifier.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const PatronCategory = DB.Entity(import.meta.url, {
     name: "PatronCategory",
     namePlural: "PatronCategories",

package/lib/types/PersonalityTrait.js

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { PersonalityTraitIdentifier } from "./_Identifier.js";
 import { PersonalityTraitPrerequisites } from "./_Prerequisite.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
 import { src } from "./source/_PublicationRef.js";
 export const PersonalityTrait = DB.Entity(import.meta.url, {

package/lib/types/Profession.d.ts

@@ -675,7 +675,8 @@ export declare const Profession: DB.Entity<"Profession", {
                     max: DB.MemberDecl<DB.Integer, true>;
                 }>>;
             }, []>>, false>;
-            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+                SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
                 General: DB.EnumCase<DB.ReferenceIdentifier>;
                 Race: DB.EnumCase<DB.ReferenceIdentifier>;
                 Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -712,7 +713,8 @@ export declare const Profession: DB.Entity<"Profession", {
                     max: DB.MemberDecl<DB.Integer, true>;
                 }>>;
             }, []>>, false>;
-            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+                SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
                 General: DB.EnumCase<DB.ReferenceIdentifier>;
                 Race: DB.EnumCase<DB.ReferenceIdentifier>;
                 Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -749,7 +751,8 @@ export declare const Profession: DB.Entity<"Profession", {
                     max: DB.MemberDecl<DB.Integer, true>;
                 }>>;
             }, []>>, false>;
-            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+                SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
                 General: DB.EnumCase<DB.ReferenceIdentifier>;
                 Race: DB.EnumCase<DB.ReferenceIdentifier>;
                 Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -786,7 +789,8 @@ export declare const Profession: DB.Entity<"Profession", {
                     max: DB.MemberDecl<DB.Integer, true>;
                 }>>;
             }, []>>, false>;
-            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+                SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
                 General: DB.EnumCase<DB.ReferenceIdentifier>;
                 Race: DB.EnumCase<DB.ReferenceIdentifier>;
                 Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1542,7 +1546,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1579,7 +1584,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1616,7 +1622,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1653,7 +1660,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;

package/lib/types/Race.d.ts

@@ -150,7 +150,8 @@ export declare const Race: DB.Entity<"Race", {
                     max: DB.MemberDecl<DB.Integer, true>;
                 }>>;
             }, []>>, false>;
-            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+                SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
                 General: DB.EnumCase<DB.ReferenceIdentifier>;
                 Race: DB.EnumCase<DB.ReferenceIdentifier>;
                 Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -187,7 +188,8 @@ export declare const Race: DB.Entity<"Race", {
                     max: DB.MemberDecl<DB.Integer, true>;
                 }>>;
             }, []>>, false>;
-            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+                SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
                 General: DB.EnumCase<DB.ReferenceIdentifier>;
                 Race: DB.EnumCase<DB.ReferenceIdentifier>;
                 Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -224,7 +226,8 @@ export declare const Race: DB.Entity<"Race", {
                     max: DB.MemberDecl<DB.Integer, true>;
                 }>>;
             }, []>>, false>;
-            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+                SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
                 General: DB.EnumCase<DB.ReferenceIdentifier>;
                 Race: DB.EnumCase<DB.ReferenceIdentifier>;
                 Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -261,7 +264,8 @@ export declare const Race: DB.Entity<"Race", {
                     max: DB.MemberDecl<DB.Integer, true>;
                 }>>;
             }, []>>, false>;
-            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+                SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
                 General: DB.EnumCase<DB.ReferenceIdentifier>;
                 Race: DB.EnumCase<DB.ReferenceIdentifier>;
                 Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -488,7 +492,8 @@ export declare const RaceVariant: DB.Entity<"RaceVariant", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -525,7 +530,8 @@ export declare const RaceVariant: DB.Entity<"RaceVariant", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -562,7 +568,8 @@ export declare const RaceVariant: DB.Entity<"RaceVariant", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -599,7 +606,8 @@ export declare const RaceVariant: DB.Entity<"RaceVariant", {
                 max: DB.MemberDecl<DB.Integer, true>;
             }>>;
         }, []>>, false>;
-        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
             Skill: DB.EnumCase<DB.ReferenceIdentifier>;

package/lib/types/TargetCategory.js

@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { TargetCategoryIdentifier } from "./_Identifier.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const TargetCategory = DB.Entity(import.meta.url, {
     name: "TargetCategory",
     namePlural: "TargetCategories",

package/lib/types/_ActivatableNonMundane.js

@@ -1,11 +1,11 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { StandaloneCostMap } from "./_ActivatableSkillCost.js";
 import { DurationUnitValue } from "./_ActivatableSkillDuration.js";
 import { ParameterMap } from "./_ActivatableSkillParameterMap.js";
 import { AspectIdentifier, PropertyIdentifier } from "./_Identifier.js";
 import { VolumePointsOptionReferenceIdentifier } from "./_IdentifierGroup.js";
 import { ResponsiveText, ResponsiveTextOptional } from "./_ResponsiveText.js";
+import { NestedTranslationMap } from "./Locale.js";
 const EnchantmentCost = DB.Enum(import.meta.url, {
     name: "EnchantmentCost",
     values: () => ({

package/lib/types/_ActivatableSelectOptionCategory.js

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { CeremonyIdentifier, CloseCombatTechniqueIdentifier, ElementIdentifier, LiturgicalChantIdentifier, PropertyIdentifier, RangedCombatTechniqueIdentifier, RitualIdentifier, SkillGroupIdentifier, SkillIdentifier, SpellIdentifier, TargetCategoryIdentifier, } from "./_Identifier.js";
 import { ActivatableIdentifier, CombatTechniqueIdentifier, SkillishIdentifier, } from "./_IdentifierGroup.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const SelectOptionCategory = DB.Enum(import.meta.url, {
     name: "SelectOptionCategory",
     values: () => ({

package/lib/types/_ActivatableSelectOptions.js

@@ -1,11 +1,11 @@
 import { isEmpty, isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import * as DB from "tsondb/schema/dsl";
 import { Case, fromUniformCase, } from "tsondb/schema/gen";
-import { NestedTranslationMap } from "./Locale.js";
 import { SelectOptionCategory } from "./_ActivatableSelectOptionCategory.js";
 import { NewSkillApplication, SkillUse } from "./_ActivatableSkillApplicationsAndUses.js";
 import { SelectOptionParentIdentifier } from "./_IdentifierGroup.js";
 import { GeneralPrerequisites } from "./_Prerequisite.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
 import { optionalSrc } from "./source/_PublicationRef.js";
 const SelectOptions = DB.TypeAlias(import.meta.url, {

package/lib/types/_ActivatableSkill.d.ts

@@ -1,5 +1,5 @@
 /**
- * @title Activatable Skill
+ * @module Activatable Skill
  */
 import * as DB from "tsondb/schema/dsl";
 import { MathOperation } from "./_MathExpression.ts";

package/lib/types/_ActivatableSkill.js

@@ -1,5 +1,5 @@
 /**
- * @title Activatable Skill
+ * @module Activatable Skill
  */
 import * as DB from "tsondb/schema/dsl";
 import { FastCastingTime, SlowCastingTime } from "./_ActivatableSkillCastingTime.js";

package/lib/types/_ActivatableSkillApplicationsAndUses.js

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { SkillIdentifier } from "./_Identifier.js";
 import { NewSkillApplicationOrUseParentIdentifier } from "./_IdentifierGroup.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const NewSkillApplication = DB.Entity(import.meta.url, {
     name: "NewSkillApplication",
     namePlural: "NewSkillApplications",

package/lib/types/_ActivatableSkillCastingTime.js

@@ -1,8 +1,8 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
-import { SlowSkillCastingTimeUnit } from "./SkillModificationLevel.js";
 import { SkillModificationLevelIdentifier } from "./_Identifier.js";
 import { ResponsiveTextOptional } from "./_ResponsiveText.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { SlowSkillCastingTimeUnit } from "./SkillModificationLevel.js";
 export const CastingTime = DB.GenEnum(import.meta.url, {
     name: "CastingTime",
     parameters: [DB.Param("NonModifiable")],

package/lib/types/_ActivatableSkillDuration.js

@@ -134,7 +134,7 @@ const CustomDurationUnit = DB.TypeAlias(import.meta.url, {
                 comment: "A translation for a numeric value of the custom duration unit, e.g. ‘3 days’. The translation string can and should make use of the `$value` and `$style` variables. The `$style` variable can be either `interval` or `default`.",
                 type: DB.String({
                     minLength: 1,
-                    pattern: /^\.input \{\$value :number\}[\n ]\.input \{\$style :string\}/,
+                    pattern: /^\.input \{\$value :number\}[\n ]\.input \{\$style :string\}/u,
                 }),
             }),
             full: DB.Required({
@@ -151,7 +151,7 @@ const CustomDurationUnit = DB.TypeAlias(import.meta.url, {
                 comment: "A translation for a numeric value of the custom duration unit for use in small spaces, e.g. ‘3 d.’. The translation string can and should make use of the `$value` and `$style` variables. The `$style` variable can be either `interval` or `default`.",
                 type: DB.String({
                     minLength: 1,
-                    pattern: /^\.input \{\$value :number\}[\n ]\.input \{\$style :string\}/,
+                    pattern: /^\.input \{\$value :number\}[\n ]\.input \{\$style :string\}/u,
                 }),
             }),
             compressed: DB.Required({

package/lib/types/_ActivatableSkillTargetCategory.js

@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { TargetCategoryIdentifier } from "./_Identifier.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const AffectedTargetCategories = DB.TypeAlias(import.meta.url, {
     name: "AffectedTargetCategories",
     comment: `The target category – the kind of creature or object – the skill affects.

package/lib/types/_ArcaneTradition.js

@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "./Locale.js";
 import { ArcaneTraditionPrerequisites } from "./_Prerequisite.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const ArcaneTraditionType = (translationName) => () => DB.Object({
     prerequisites: DB.Required({
         type: DB.IncludeIdentifier(ArcaneTraditionPrerequisites),