@optolith/entity-descriptions 0.4.11 → 0.4.13

package/lib/entities/partial/rated/improvementCost.d.ts

@@ -1,4 +1,4 @@
-import type { ImprovementCost } from "optolith-database-schema/gen";
+import type { ImprovementCost } from "@optolith/database-schema/gen";
 import { type RawDefinitionListEntityDescriptionSectionItem } from "../../../index.js";
 import { type StdReader } from "../reader.js";
 /**

package/lib/entities/partial/rated/skillCheck.d.ts

@@ -1,4 +1,4 @@
-import type { SkillCheckPenalty as GeneralSkillCheckPenalty, MagicalRuneCombatTechniqueCheckPenalty, SkillCheck } from "optolith-database-schema/gen";
+import type { SkillCheckPenalty as GeneralSkillCheckPenalty, MagicalRuneCombatTechniqueCheckPenalty, SkillCheck } from "@optolith/database-schema/gen";
 import { type IdMap } from "../../../index.js";
 import { type StdReader } from "../reader.js";
 /**

package/lib/entities/partial/rated/skillCheck.js

@@ -8,8 +8,8 @@ import { MISSING_VALUE } from "../unknown.js";
 export const renderSkillCheck = (check) => Reader.asks(({ translate, translateMap, getInstanceById }) => ({
     label: translate("Check"),
     value: check
-        .map(id => translateMap(getInstanceById("Attribute", id)?.translations)
-        ?.abbreviation ?? MISSING_VALUE)
+        .map(id => translateMap(getInstanceById("Attribute", id)?.translations)?.abbreviation ??
+        MISSING_VALUE)
         .join("/"),
 }));
 const renderSkillCheckPenalty = (idMap, penalty) => {
@@ -53,7 +53,9 @@ const renderSkillCheckPenalty = (idMap, penalty) => {
 export const renderSkillCheckWithPenalty = (check, checkPenalty, idMap) => checkPenalty === undefined
     ? renderSkillCheck(check)
     : renderSkillCheck(check).thenW(checkText => renderSkillCheckPenalty(idMap, checkPenalty)
-        .then(penaltyText => responsiveTranslateR(" (modified by {$modifier})", " (−{$modifier})", { modifier: penaltyText }))
+        .then(penaltyText => responsiveTranslateR(" (modified by {$modifier})", " (−{$modifier})", {
+        modifier: penaltyText,
+    }))
         .map(penaltyText => ({
         ...checkText,
         value: checkText.value + penaltyText,

package/lib/entities/partial/reader.d.ts

@@ -1,5 +1,5 @@
 import { Reader } from "@elyukai/utils/reader";
-import type { ChildEntityMap, EntityMap, FastSkillModificationLevelConfig, ResponsiveText, ResponsiveTextOptional, SkillModificationLevel, SlowSkillModificationLevelConfig } from "optolith-database-schema/gen";
+import type { ChildEntityMap, EntityMap, FastSkillModificationLevelConfig, ResponsiveText, ResponsiveTextOptional, SkillModificationLevel, SlowSkillModificationLevelConfig } from "@optolith/database-schema/gen";
 import type { IdArgsVariant } from "tsondb/schema/gen";
 import type { GetAllChildInstancesForParent, GetAllInstances, GetInstanceById } from "../../helpers/getTypes.js";
 import type { FormatNumber, LocaleCompare, LocaleJoin, LocaleJoinType } from "../../helpers/locale.js";
@@ -202,6 +202,12 @@ export declare const getChildInstancesForInstanceIdR: <CE extends keyof ChildEnt
     id: string;
     content: ChildEntityMap[CE][0];
 }[]>;
+/**
+ * Gets a function to retrieve all child instances of an entity from the database by their child entity name and their parent’s identifier.
+ */
+export declare const getChildInstancesForInstanceIdFnR: <CE extends keyof ChildEntityMap>() => Reader<{
+    getChildInstancesForInstanceId: GetAllChildInstancesForParent<CE>;
+}, GetAllChildInstancesForParent<CE>>;
 /**
  * Joins a list of strings according to the locale’s rules for the given type.
  */

package/lib/entities/partial/reader.js

@@ -83,6 +83,10 @@ export const getAllInstancesR = (entityName) => Reader.asks(env => env.getAllIns
  * Retrieves all child instances of an entity from the database by their child entity name and their parent’s identifier.
  */
 export const getChildInstancesForInstanceIdR = (entityName, parentId) => Reader.asks(env => env.getChildInstancesForInstanceId(entityName, parentId));
+/**
+ * Gets a function to retrieve all child instances of an entity from the database by their child entity name and their parent’s identifier.
+ */
+export const getChildInstancesForInstanceIdFnR = () => Reader.asks(env => env.getChildInstancesForInstanceId);
 /**
  * Joins a list of strings according to the locale’s rules for the given type.
  */

package/lib/entities/partial/responsiveText.d.ts

@@ -1,5 +1,5 @@
 import { Reader } from "@elyukai/utils/reader";
-import type { ResponsiveText, ResponsiveTextOptional, ResponsiveTextReplace } from "optolith-database-schema/gen";
+import type { ResponsiveText, ResponsiveTextOptional, ResponsiveTextReplace } from "@optolith/database-schema/gen";
 import { type LocaleMap } from "../../helpers/translate.js";
 import { type StdEnv } from "./reader.js";
 /**

package/lib/entities/poison.d.ts

@@ -1,4 +1,4 @@
-import type { ActivatableIdentifier, RatedIdentifier } from "optolith-database-schema/gen";
+import type { ActivatableIdentifier, RatedIdentifier } from "@optolith/database-schema/gen";
 import type { GetInstanceById } from "../helpers/getTypes.js";
 import type { IdMap } from "../index.js";
 import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";

package/lib/entities/profession.d.ts

@@ -1,4 +1,4 @@
-import type { MagicalActionIdentifier, ProfessionSpecialAbilityIdentifier, RatedIdentifier } from "optolith-database-schema/gen";
+import type { MagicalActionIdentifier, ProfessionSpecialAbilityIdentifier, RatedIdentifier } from "@optolith/database-schema/gen";
 import type { GetAllChildInstancesForParent, GetAllInstances, GetInstanceById } from "../helpers/getTypes.js";
 import { type GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";
 /**

package/lib/entities/profession.js

@@ -11,10 +11,10 @@ import { Case, fromUniformCase } from "tsondb/schema/gen";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { combineNameComponents, getNameComponents, renderActivatableNameComponents, renderCombinedActivatableNameComponents, } from "./partial/activatableNameChunks.js";
 import { renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
-import { attributedCustomName, attributedInstance, attributedName } from "./partial/markdown.js";
+import { attributedCustomName, attributedInstance, attributedName, attributedNameFromInstance, } from "./partial/markdown.js";
 import { printProfessionPrerequisites } from "./partial/prerequisites/index.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
-import { attributedCustomNameR, attributedNameR, customNameR, formatR, getChildInstancesForInstanceIdR, getInstanceByIdR, localeCompareR, localeJoinR, localeSortR, strictNameR, translateMapFnR, translateR, translationR, } from "./partial/reader.js";
+import { attributedCustomNameR, attributedNameR, customNameR, formatR, getChildInstancesForInstanceIdFnR, getChildInstancesForInstanceIdR, getInstanceByIdR, localeCompareR, localeJoinR, localeSortR, strictNameR, translateMapFnR, translateR, translationR, } from "./partial/reader.js";
 import { MISSING_VALUE, UNHANDLED_VALUE } from "./partial/unknown.js";
 const prepareProfessionPackages = (professionId) => Reader.asks(({ getInstanceById, getChildInstancesForInstanceId }) => getChildInstancesForInstanceId("ProfessionPackage", professionId)
     .map((professionPackage) => ({
@@ -133,10 +133,10 @@ const renderSkillsOption = (professionPackages, skillGroup) => allSame(professio
         })
         : Reader.traverse(professionPackages[0].content.options.skills.specific, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE))
             .thenW(localeSortR)
-            .thenW(list => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
+            .thenW(list => translateR("maximum SR per skill: {$maxSR}", { maxSR: 8 }).then(maxSRText => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
             apValue,
-            list: list.join(", "),
-        }))) ?? Reader.of(undefined))
+            list: list.join(", ") + parensIf(maxSRText),
+        })))) ?? Reader.of(undefined))
     : Reader.traverse(professionPackages, pkg => {
         const skillsOption = pkg.content.options?.skills;
         return skillsOption === undefined
@@ -148,10 +148,10 @@ const renderSkillsOption = (professionPackages, skillGroup) => allSame(professio
                 })
                 : Reader.traverse(skillsOption.specific, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE))
                     .thenW(localeSortR)
-                    .thenW(list => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
+                    .thenW(list => translateR("maximum SR per skill: {$maxSR}", { maxSR: 8 }).then(maxSRText => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
                     apValue: skillsOption.ap_value,
-                    list: list.join(", "),
-                }));
+                    list: list.join(", ") + parensIf(maxSRText),
+                })));
     }).map(list => list.join(" / "));
 const renderCantripList = (cantripIds) => Reader.traverse(cantripIds, id => attributedNameR("profession", "Cantrip", id).map(name => name ?? MISSING_VALUE))
     .thenW(localeSortR)
@@ -308,7 +308,8 @@ const getEnhancementNameComponents = (getInstanceById, translate, translateMap,
         id: Case("Enhancement", id),
         parent: instance.parent,
         base: getEnhancementBaseName(translate, instance, attributedName(translateMap, getInstanceById, "profession", instance.parent) ?? MISSING_VALUE),
-        options: translateMap(instance.translations)?.name ?? MISSING_VALUE,
+        options: attributedNameFromInstance(translateMap, instance, "prerequisite", "Enhancement", id) ??
+            MISSING_VALUE,
     };
 };
 const renderEnhancementNameComponents = (chunk) => [chunk.base, chunk.options].join(" ");
@@ -354,9 +355,9 @@ const getSpecialAbilityNameComponents = (getInstanceById, getResolvedSelectOptio
 const wrapActivatableInAttributedString = (text, id) => attributedInstance(text, id.kind, fromUniformCase(id), { context: '"prerequisite"' });
 const renderSingleActivatableNameChunk = (translateMap, chunk) => chunk === undefined
     ? MISSING_VALUE
-    : wrapActivatableInAttributedString(isEnhancementNameComponents(chunk)
+    : isEnhancementNameComponents(chunk)
         ? renderEnhancementNameComponents(chunk)
-        : renderActivatableNameComponents(translateMap, chunk, false), chunk.id);
+        : wrapActivatableInAttributedString(renderActivatableNameComponents(translateMap, chunk, false), chunk.id);
 const renderSpecialAbilityName = (specialAbility) => Reader.asks(({ translate, translateMap, localeJoin, getInstanceById, getResolvedSelectOptionById, }) => {
     switch (specialAbility.kind) {
         case "Constant": {
@@ -598,7 +599,9 @@ const groupProfessionVariantsThatContainTheSameChanges = (variants) => Reader.as
     return acc;
 }, []));
 const renderProfessionVariants = (professionPackages) => professionPackages.length > 1
-    ? Reader.of(UNHANDLED_VALUE)
+    ? getChildInstancesForInstanceIdFnR().map(getChildInstancesForInstanceId => professionPackages.some(professionPackage => getChildInstancesForInstanceId("ProfessionVariant", professionPackage.id).length > 0)
+        ? UNHANDLED_VALUE
+        : undefined)
     : getChildInstancesForInstanceIdR("ProfessionVariant", professionPackages[0].id).thenW(variants => groupProfessionVariantsThatContainTheSameChanges(variants).thenW(groupedVariants => Reader.traverse(groupedVariants, variant => renderProfessionVariant(professionPackages[0].content, variant))
         .map(list => list.filter(isNotNullish))
         .thenW(list => list.length === 0
@@ -707,10 +710,10 @@ export const getProfessionVersionEntityDescription = createEntityDescriptionCrea
                             value,
                         })
                         .run(env),
-                    renderValueWithPossibleTranslation("Suggested Advantages", entry.suggested_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values).run(env), translation.suggested_advantages).run(env),
-                    renderValueWithPossibleTranslation("Suggested Disadvantages", entry.suggested_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values).run(env), translation.suggested_disadvantages).run(env),
-                    renderValueWithPossibleTranslation("Unsuitable Advantages", entry.unsuitable_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values).run(env), translation.unsuitable_advantages).run(env),
-                    renderValueWithPossibleTranslation("Unsuitable Disadvantages", entry.unsuitable_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values).run(env), translation.unsuitable_disadvantages).run(env),
+                    renderValueWithPossibleTranslation("Suggested Advantages", entry.suggested_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values, translate("none")).run(env), translation.suggested_advantages).run(env),
+                    renderValueWithPossibleTranslation("Suggested Disadvantages", entry.suggested_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values, translate("none")).run(env), translation.suggested_disadvantages).run(env),
+                    renderValueWithPossibleTranslation("Unsuitable Advantages", entry.unsuitable_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values, translate("none")).run(env), translation.unsuitable_advantages).run(env),
+                    renderValueWithPossibleTranslation("Unsuitable Disadvantages", entry.unsuitable_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values, translate("none")).run(env), translation.unsuitable_disadvantages).run(env),
                     renderProfessionVariants(professionPackages)
                         .map(value => value === undefined
                         ? undefined

package/lib/entities/race.d.ts

@@ -1,4 +1,5 @@
 import type { CountInstances, GetAllChildInstancesForParent, GetInstanceById } from "../helpers/getTypes.js";
+import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";
 /**
  * Get a JSON representation of the rules text for a race.
  */
@@ -6,4 +7,5 @@ export declare const getRaceEntityDescription: import("../creator.js").EntityDes
     getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Advantage" | "Disadvantage" | "Culture" | "DerivedCharacteristic">;
     countInstances: CountInstances<"Attribute">;
     getChildInstancesForInstanceId: GetAllChildInstancesForParent<"RaceVariant">;
+    getResolvedSelectOptionById: GetResolvedSelectOptionById;
 }, import("../index.js").EntityDescription>;

package/lib/entities/race.js

@@ -1,21 +1,21 @@
 import { anySameIndices } from "@elyukai/utils/array/filters";
-import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
+import { ensureNonEmpty, isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { deepEqual } from "@elyukai/utils/equality";
 import { on } from "@elyukai/utils/function";
-import { isNotNullish } from "@elyukai/utils/nullable";
+import { isNotNullish, mapNullable } from "@elyukai/utils/nullable";
 import { compareNumber } from "@elyukai/utils/ordering";
 import { Reader } from "@elyukai/utils/reader";
 import { sign } from "@elyukai/utils/string/number";
 import { createEntityDescriptionCreator } from "../creator.js";
-import { renderCommonnessRatedAdvantagesAndDisadvantages, renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
-import { attributedCustomName, attributedName } from "./partial/markdown.js";
+import { renderCommonnessRatedAdvantagesAndDisadvantages, renderCommonnessRatedAdvantagesOrDisadvantages, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
+import { attributedCustomName, attributedName, attributedNameFromTranslation, } from "./partial/markdown.js";
 import { getInstanceByIdR, translateMapR, } from "./partial/reader.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
 const renderBaseValues = (values) => Reader.traverse(Object.entries(values), ([id, { value }]) => getInstanceByIdR("DerivedCharacteristic", id).thenW(derivedCharacteristic => translateMapR(derivedCharacteristic?.translations).thenW(translation => Reader.asks(({ translate }) => [
     derivedCharacteristic?.position ?? 0,
     {
         label: translate("{$derivedCharacteristic} Base Value", {
-            derivedCharacteristic: translation?.name ?? MISSING_VALUE,
+            derivedCharacteristic: attributedNameFromTranslation(translation, "base-values", "DerivedCharacteristic", id) ?? MISSING_VALUE,
         }),
         value: value < 0 ? sign(value) : value.toFixed(),
     },
@@ -28,7 +28,7 @@ const renderAttributeAdjustmentsItem = (totalAttributesCount, adjustments) => Re
         ...(adjustments.selectable?.map(adj => `${adj.list.length === totalAttributesCount ? translate("one attribute of your choice") : localeJoin(adj.list.map(getAttributeAbbreviation), "disjunction")} ${sign(adj.value)}`) ?? []),
     ].join("; ");
 });
-const renderVariantValues = (label, variants, selector, renderValue, translationSelector) => Reader.asks(({ translate, translateMap, localeCompare, localeJoin, }) => {
+const renderVariantValues = (label, variants, selector, renderValue, translationSelector, allowEmpty = false, textPrefix) => Reader.asks(({ translate, translateMap, localeCompare, localeJoin, }) => {
     const values = variants.map(variant => {
         const translation = translateMap(variant.translations);
         return {
@@ -39,37 +39,52 @@ const renderVariantValues = (label, variants, selector, renderValue, translation
                 : undefined,
         };
     });
-    const sameValues = anySameIndices(values, on(value => [value.value, value.valueTranslation], deepEqual));
-    if (isNotEmpty(sameValues) &&
-        sameValues.length === 1 &&
-        sameValues[0].length === values.length) {
-        return {
-            label: translate(label),
-            value: values[0] === undefined
-                ? MISSING_VALUE
-                : (values[0].valueTranslation ?? renderValue(values[0].value)),
-        };
+    if (isNotEmpty(values)) {
+        const sameValues = anySameIndices(values, on(value => [value.value, value.valueTranslation], deepEqual));
+        if (values.length === 1 ||
+            (isNotEmpty(sameValues) &&
+                sameValues.length === 1 &&
+                sameValues[0].length === values.length)) {
+            return values[0].value === undefined &&
+                values[0].valueTranslation === undefined &&
+                allowEmpty
+                ? undefined
+                : mapNullable(
+                /* values[0].valueTranslation ?? */ renderValue(values[0].value, false), renderedValue => ({
+                    label: translate(label),
+                    value: (textPrefix ?? "") + renderedValue,
+                }));
+        }
+        else {
+            return {
+                label: translate(label),
+                value: [
+                    ...(textPrefix !== undefined ? [{ type: "plain", text: textPrefix }] : []),
+                    {
+                        type: "definitionList",
+                        style: "nested",
+                        items: Map.groupBy(values
+                            .toSorted(on(item => item.name, localeCompare))
+                            .map(value => mapNullable(
+                        /* value.valueTranslation ?? */ renderValue(value.value, true), renderedValue => ({
+                            label: value.name,
+                            value: renderedValue,
+                        })))
+                            .filter(isNotNullish), item => item.value)
+                            .entries()
+                            .map(([value, items]) => ({
+                            label: localeJoin(items.map(item => item.label), "conjunction"),
+                            value,
+                        }))
+                            .toArray(),
+                    },
+                ],
+            };
+        }
     }
     else {
-        return {
-            label: translate(label),
-            value: [
-                {
-                    type: "definitionList",
-                    style: "nested",
-                    items: Map.groupBy(values.toSorted(on(item => item.name, localeCompare)).map(value => ({
-                        label: value.name,
-                        value: value.valueTranslation ?? renderValue(value.value),
-                    })), item => item.value)
-                        .entries()
-                        .map(([value, items]) => ({
-                        label: localeJoin(items.map(item => item.label), "conjunction"),
-                        value,
-                    }))
-                        .toArray(),
-                },
-            ],
-        };
+        // at least one value and thus one variant is required
+        return undefined;
     }
 });
 const renderAutomaticAdvantagesOrDisadvantages = (entity, items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
@@ -88,7 +103,7 @@ const renderCommonCultures = (items) => Reader.asks(({ translate, translateMap,
 /**
  * Get a JSON representation of the rules text for a race.
  */
-export const getRaceEntityDescription = createEntityDescriptionCreator(({ getInstanceById, countInstances, getChildInstancesForInstanceId }, { translate, translateMap, join: localeJoin, compare: localeCompare }, { id, content: entry }) => {
+export const getRaceEntityDescription = createEntityDescriptionCreator(({ getInstanceById, countInstances, getChildInstancesForInstanceId, getResolvedSelectOptionById, }, { translate, translateMap, join: localeJoin, compare: localeCompare }, { id, content: entry }) => {
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
@@ -100,6 +115,7 @@ export const getRaceEntityDescription = createEntityDescriptionCreator(({ getIns
         translateMap,
         localeJoin,
         localeCompare,
+        getResolvedSelectOptionById,
         getInstanceById,
     };
     return {
@@ -118,23 +134,26 @@ export const getRaceEntityDescription = createEntityDescriptionCreator(({ getIns
                     ...renderBaseValues(entry.base_values).run(env),
                     renderVariantValues("Attribute Adjustments", raceVariants, v => v.attribute_adjustments, attrs => renderAttributeAdjustmentsItem(totalAttributesCount, attrs).run(env)).run(env),
                     renderVariantValues("Common Cultures", raceVariants, v => v.common_cultures, cultures => renderCommonCultures(cultures).run(env)).run(env),
-                    entry.automatic_advantages === undefined
-                        ? undefined
-                        : renderValueWithPossibleTranslation("Automatic Advantages", entry.automatic_advantages, v => renderAutomaticAdvantagesOrDisadvantages("Advantage", v).run(env), translation.automatic_advantages).run(env),
-                    entry.automatic_disadvantages === undefined
-                        ? undefined
-                        : renderValueWithPossibleTranslation("Automatic Disadvantages", entry.automatic_disadvantages, v => renderAutomaticAdvantagesOrDisadvantages("Disadvantage", v).run(env), translation.automatic_disadvantages).run(env),
-                    entry.strongly_recommended_advantages === undefined &&
-                        entry.strongly_recommended_disadvantages === undefined
+                    renderVariantValues("Automatic Advantages", raceVariants, v => v.automatic_advantages, advs => renderAutomaticAdvantagesOrDisadvantages("Advantage", advs).run(env), vt => vt.automatic_advantages, true).run(env),
+                    renderVariantValues("Automatic Disadvantages", raceVariants, v => v.automatic_disadvantages, advs => renderAutomaticAdvantagesOrDisadvantages("Disadvantage", advs).run(env), vt => vt.automatic_disadvantages, true).run(env),
+                    renderVariantValues("Strongly recommended Advantages and Disadvantages", raceVariants, v => v.strongly_recommended_advantages === undefined &&
+                        v.strongly_recommended_disadvantages === undefined
                         ? undefined
-                        : {
-                            label: translate("Strongly recommended Advantages and Disadvantages"),
-                            value: `${translate("The following advantages and disadvantages distinguish Aventurian {$race}. You should choose these advantages and disadvantages. If you don’t want to take them, talk to your GM.", { race: translation.name })} ${renderCommonnessRatedAdvantagesAndDisadvantages(entry.strongly_recommended_advantages, entry.strongly_recommended_disadvantages).run(env)}`,
-                        },
-                    renderVariantValues("Common Advantages", raceVariants, v => v.common_advantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", advs).run(env), vt => vt.common_advantages).run(env),
-                    renderVariantValues("Common Disadvantages", raceVariants, v => v.common_disadvantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", advs).run(env), vt => vt.common_disadvantages).run(env),
-                    renderVariantValues("Uncommon Advantages", raceVariants, v => v.uncommon_advantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", advs).run(env), vt => vt.uncommon_advantages).run(env),
-                    renderVariantValues("Uncommon Disadvantages", raceVariants, v => v.uncommon_disadvantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", advs).run(env), vt => vt.uncommon_disadvantages).run(env),
+                        : [
+                            v.strongly_recommended_advantages,
+                            v.strongly_recommended_disadvantages,
+                        ], (advsDisadvs, isSplit) => advsDisadvs === undefined
+                        ? isSplit
+                            ? undefined
+                            : translate("none")
+                        : renderCommonnessRatedAdvantagesAndDisadvantages(...advsDisadvs, isSplit ? undefined : translate("none")).run(env), vt => ensureNonEmpty([
+                        vt.strongly_recommended_advantages,
+                        vt.strongly_recommended_disadvantages,
+                    ].filter(isNotNullish))?.join("; "), true, `${translate("The following advantages and disadvantages distinguish Aventurian {$race}. You should choose these advantages and disadvantages. If you don’t want to take them, talk to your GM.", { race: translation.name })} `).run(env),
+                    renderVariantValues("Common Advantages", raceVariants, v => v.common_advantages, (advs, isSplit) => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", advs, isSplit ? undefined : translate("none")).run(env), vt => vt.common_advantages).run(env),
+                    renderVariantValues("Common Disadvantages", raceVariants, v => v.common_disadvantages, (advs, isSplit) => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", advs, isSplit ? undefined : translate("none")).run(env), vt => vt.common_disadvantages).run(env),
+                    renderVariantValues("Uncommon Advantages", raceVariants, v => v.uncommon_advantages, (advs, isSplit) => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", advs, isSplit ? undefined : translate("none")).run(env), vt => vt.uncommon_advantages).run(env),
+                    renderVariantValues("Uncommon Disadvantages", raceVariants, v => v.uncommon_disadvantages, (advs, isSplit) => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", advs, isSplit ? undefined : translate("none")).run(env), vt => vt.uncommon_disadvantages).run(env),
                 ],
             },
         ],

package/lib/entities/skill.d.ts

@@ -1,4 +1,4 @@
-import type { ActivatableIdentifier } from "optolith-database-schema/gen";
+import type { ActivatableIdentifier } from "@optolith/database-schema/gen";
 import type { GetAllChildInstancesForParent, GetAllInstances, GetInstanceById } from "../helpers/getTypes.js";
 import type { GetAllResolvedNewSkillApplications, GetAllResolvedSkillUses } from "../index.js";
 /**

package/lib/entities/spell.d.ts

@@ -1,4 +1,4 @@
-import { type ActivatableIdentifier, type RatedIdentifier } from "optolith-database-schema/gen";
+import { type ActivatableIdentifier, type RatedIdentifier } from "@optolith/database-schema/gen";
 import type { GetAllChildInstancesForParent, GetInstanceById } from "../helpers/getTypes.js";
 import { type IdMap } from "../index.js";
 import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";

package/lib/helpers/getTypes.d.ts

@@ -1,4 +1,4 @@
-import type * as Database from "optolith-database-schema/gen";
+import type * as Database from "@optolith/database-schema/gen";
 import type { IdArgsVariant } from "tsondb/schema/gen";
 export type GetInstanceById<in T extends Extract<keyof Database.EntityMap, string>> = <U extends T>(...args: IdArgsVariant<Database.EntityMap, U>) => Database.EntityMap[U] | undefined;
 export type GetAllInstances<T extends keyof Database.EntityMap> = <U extends T>(entity: U) => {

package/lib/helpers/locale.d.ts

@@ -1,5 +1,5 @@
+import type { LocaleMeasurementAdjustments } from "@optolith/database-schema/gen";
 import type { Compare } from "@optolith/helpers/compare";
-import type { LocaleMeasurementAdjustments } from "optolith-database-schema/gen";
 import type { Format, Translate, TranslateMap } from "./translate.js";
 /**
  * The type of list to join in a locale-aware way.

package/lib/helpers/translate.d.ts

@@ -1,4 +1,4 @@
-import type { Locale } from "optolith-database-schema/gen";
+import type { Locale } from "@optolith/database-schema/gen";
 import { ResponsiveTextSize } from "../entities/partial/responsiveText.js";
 /**
  * The type of all translations