configs/

game_config.rs

use essences::abilities::{AbilityRarity, AbilityTemplate};
use essences::ability_presets::AbilityPresetsSettings;
use essences::ability_stones::AbilityStoneTemplate;
use essences::bundles::BundleRaw;
use essences::chats::ChatSettings;
use essences::class;
use essences::cores::LawTemplate;
use essences::currency::Currency;
use essences::dungeons::DungeonTemplate;
use essences::effect::Effect;
use essences::fighting::FightTemplate;
use essences::game::{
    AbilitySlotsLevel, Chapter, CharacterLevel, CharacterLevelFormula, EntityTemplate,
    PetSlotsLevel,
};
use essences::gatings::Gatings;
use essences::generation::{BotsSettings, UsersGeneratingSettings};
use essences::gift::GiftTemplate;
use essences::item_case::{InventoryLevel, ItemCasesSettingsByLevel};
use essences::items::{Attribute, ItemRarity, ItemTemplate};
use essences::mail::MailTemplate;
use essences::offers::{OfferTemplate, ShopTabConfig};
use essences::pets::{PetRarity, PetTemplate};
use essences::progress_pass::ProgressPassConfig;
use essences::quest::{QuestGroupType, QuestTemplate, QuestsProgressionSettings};
use essences::ratings::RatingSettings;
use essences::referrals::ReferralLevelInfo;
use essences::skins::{ConfigSkin, SkinsSettings};
use essences::vassals::VassalTaskTemplate;
use schemars::JsonSchema;

use serde::{Deserialize, Serialize};
use tsify_next::Tsify;

use crate::abilities::{AbilityCasesSettingsByLevel, AbilityLevel, Projectile};
use crate::ability_stones::AbilityStoneSettings;
use crate::ads_settings::{AdsSettings, BirdVariant};
use crate::afk_rewards::{AfkRewardBonusType, AfkRewardsByLevel, AfkRewardsSettings};
use crate::artifacts::{ArtifactStoneTemplate, ArtifactTemplate, ArtifactsSettings};
use crate::buffs::BuffTemplate;
use crate::cheats::{CheatScript, TestPlayerScript};
use crate::collection_power::CollectionPowerSettings;
use crate::cores::CoresSettings;
use crate::events::EventDescription;
use crate::fighting::{ArenaLeague, ArenaSettings, FightSettings, PvpSettings};
use crate::flip::FlipSettings;
use crate::game_settings::GameSettings;
use crate::kill_faucets::KillFaucetSettings;
use crate::local_notifications::LocalNotificationsSettings;
use crate::mana::ManaSettings;
use crate::matchmaking::MatchmakingSettings;
use crate::pets::{PetCasesSettingsByLevel, PetLevel};
use crate::plinko::{MAX_PLINKO_ROWS, MIN_PLINKO_ROWS, PlinkoSettings};
use crate::portal_rarities::PortalRarity;
use crate::reports::ReportsSettings;
use crate::statue::{StatueBonusTypeConfig, StatueLevelConfig, StatueSettings};
use crate::stones::{EffectStoneTemplate, StonesSettings, TriggerStoneTemplate};
use crate::tutorial::TutorialStep;
use crate::validated_types::NonEmptyVec;
use crate::vassals::VassalsSettings;
use essences::statue::StatueBonusGrade;
use essences::talent_tree::{TalentTemplate, TalentTreeSettings};

#[derive(Clone, Serialize, Deserialize, JsonSchema, Tsify)]
#[tsify(into_wasm_abi)]
pub struct GameConfig {
    #[schemars(title = "Атрибуты")]
    pub attributes: Vec<Attribute>,

    #[schemars(title = "Настройки сундука-гачи-айтемов")]
    pub item_cases_settings: Vec<ItemCasesSettingsByLevel>,

    #[schemars(
        title = "Настройки игры",
        description = "Отдельные значения, которые используются в игре"
    )]
    pub game_settings: GameSettings,

    #[schemars(
        title = "Настройки действий за рекламу",
        description = "Все настройки действий, связанные с рекламой"
    )]
    pub ads_settings: AdsSettings,

    #[schemars(title = "Предметы")]
    pub items: Vec<ItemTemplate>,

    #[schemars(title = "Редкости предметов")]
    pub item_rarities: Vec<ItemRarity>,

    /// Portal-specific sprites mapped onto item rarity metadata.
    #[schemars(title = "Редкости порталов")]
    pub portal_rarities: Vec<PortalRarity>,

    #[schemars(title = "Скины")]
    pub skins: Vec<ConfigSkin>,

    #[schemars(title = "Настройки скинов для кастомизации")]
    pub skins_settings: SkinsSettings,

    #[schemars(title = "Эффекты")]
    pub effects: Vec<Effect>,

    #[schemars(title = "Способности")]
    pub abilities: Vec<AbilityTemplate>,

    #[schemars(title = "Настройки сундука-гачи-скилов")]
    pub ability_cases_settings: NonEmptyVec<AbilityCasesSettingsByLevel>,

    #[schemars(title = "Редкости способностей")]
    pub ability_rarities: Vec<AbilityRarity>,

    #[schemars(title = "Уровни способностей")]
    pub ability_levels: Vec<AbilityLevel>,

    /// Catalog of ability stones — their own collection, never mixed with item
    /// or artifact stones.
    #[schemars(title = "Камни способностей")]
    pub ability_stones: Vec<AbilityStoneTemplate>,

    #[schemars(title = "Настройки камней способностей")]
    pub ability_stone_settings: AbilityStoneSettings,

    #[schemars(title = "Настройки маны")]
    pub mana_settings: ManaSettings,

    #[schemars(title = "Настройки боя")]
    pub fight_settings: FightSettings,

    /// Settings for the persistent global Real/Fantasy equipment flip gauge.
    #[schemars(title = "Настройки глобального флипа экипировки")]
    pub flip_settings: FlipSettings,

    /// Balance knobs for the twin cores, their law slots and the bridges.
    #[schemars(title = "Настройки ядер, законов и мостов")]
    pub cores_settings: CoresSettings,

    /// Numbers of the twenty Pet Facets rolled by the Team Die.
    #[schemars(title = "Настройки граней петов (Team Die)")]
    pub pet_facet_settings: crate::pet_facets::PetFacetSettings,

    /// Law catalog. A law lives in a slot on the core of its own side.
    #[schemars(title = "Законы")]
    pub laws: Vec<LawTemplate>,
    /// Tunables of the Trigger/Effect Stone system: gauge weights, trigger
    /// cooldown, the tier coefficient matrix, the socket unlock schedule and
    /// the temporary drop chance.
    #[schemars(title = "Настройки камней (триггеры/эффекты)")]
    pub stones_settings: StonesSettings,

    /// BAL-038: the shared daily anti-idle contract for every kill-driven
    /// faucet. Core Essence is absent from this table on purpose — its `D` is
    /// the reached chapter band's `R_value` in `cores_settings`.
    #[schemars(title = "Дневной анти-idle контракт kill-фаунтейнов")]
    pub kill_faucet_settings: KillFaucetSettings,

    #[schemars(title = "Каталог Trigger-камней")]
    pub trigger_stones: Vec<TriggerStoneTemplate>,

    #[schemars(title = "Каталог Effect-камней")]
    pub effect_stones: Vec<EffectStoneTemplate>,

    /// Tunables of the artifact system: the ownership bonus ladder, the
    /// duplicate ladder, the six-socket unlock schedule and the placeholder
    /// acquisition sources.
    #[schemars(title = "Настройки артефактов")]
    pub artifacts_settings: ArtifactsSettings,

    #[schemars(title = "Каталог артефактов")]
    pub artifacts: Vec<ArtifactTemplate>,

    /// Catalog of artifact stones. Ships with the six Aspect (left column)
    /// stones only — the Law column needs the cores/laws vertical.
    #[schemars(title = "Каталог камней артефакта")]
    pub artifact_stones: Vec<ArtifactStoneTemplate>,

    /// Collection Power: the passive stat bonus paid for OWNING catalog
    /// content, across stones, laws, ability stones, gacha abilities and pets.
    /// Artifacts are excluded — they already pay their own ownership bonus.
    #[schemars(title = "Настройки коллекционной силы")]
    pub collection_power: CollectionPowerSettings,

    #[schemars(title = "Враги")]
    pub entities: Vec<EntityTemplate>,

    #[schemars(title = "Шаблоны данжей")]
    pub dungeon_templates: Vec<DungeonTemplate>,

    #[schemars(title = "Шаблоны боев")]
    pub fight_templates: Vec<FightTemplate>,

    #[schemars(title = "Главы кампании")]
    pub chapters: Vec<Chapter>,

    #[schemars(title = "Уровни игрока")]
    pub character_levels: Vec<CharacterLevel>,

    #[schemars(title = "Формула бесконечных уровней игрока")]
    pub character_level_formula: CharacterLevelFormula,

    #[schemars(title = "Уровни слотов способностей")]
    pub ability_slots_levels: Vec<AbilitySlotsLevel>,

    #[schemars(title = "Реферальные уровни игрока")]
    pub patron_levels: Vec<ReferralLevelInfo>,

    #[schemars(title = "Квесты")]
    pub quests: Vec<QuestTemplate>,

    #[schemars(title = "Настройки прогрессии квестов")]
    pub quests_progression_settings: QuestsProgressionSettings,

    #[schemars(title = "Настройки вассалов")]
    pub vassals_settings: VassalsSettings,

    #[schemars(title = "Поручения")]
    pub vassal_tasks: Vec<VassalTaskTemplate>,

    #[schemars(title = "Настройки PvP")]
    pub pvp_settings: PvpSettings,

    #[schemars(title = "Подарки")]
    pub gifts: Vec<GiftTemplate>,

    #[schemars(title = "Шаблоны писем")]
    pub mail_templates: Vec<MailTemplate>,

    #[schemars(title = "Валюты")]
    pub currencies: Vec<Currency>,

    #[schemars(title = "Уровни инвентаря")]
    pub inventory_levels: Vec<InventoryLevel>,

    #[schemars(title = "Настройки арены")]
    pub arena_settings: ArenaSettings,

    #[schemars(title = "Настройки лиг")]
    pub arena_leagues: Vec<ArenaLeague>,

    #[schemars(title = "Настройки матчмейкинга")]
    pub matchmaking_settings: MatchmakingSettings,

    #[schemars(title = "Описания эвентов")]
    pub event_descriptions: Vec<EventDescription>,

    #[schemars(title = "Классы персонажа")]
    pub classes: Vec<class::Class>,

    #[schemars(title = "Уровни прокачки классов")]
    pub class_levels: Vec<class::ClassLevels>,

    #[schemars(title = "Список проджектайлов")]
    pub projectiles: Vec<Projectile>,

    #[schemars(title = "Список бандлов")]
    pub bundles: Vec<BundleRaw>,

    #[schemars(title = "Настройки пресетов способностей")]
    pub ability_presets_settings: AbilityPresetsSettings,

    #[schemars(title = "Настройки ботов")]
    pub bots_settings: BotsSettings,

    #[schemars(title = "Настройки репортов")]
    pub reports_settings: ReportsSettings,

    #[schemars(title = "Настройки афк наград")]
    pub afk_rewards_settings: AfkRewardsSettings,

    #[schemars(title = "Уровни афк наград")]
    pub afk_rewards_levels: Vec<AfkRewardsByLevel>,

    #[schemars(title = "Настройки генерации параметров пользователя")]
    pub users_generating_settings: UsersGeneratingSettings,

    #[schemars(title = "Шаги туториала")]
    pub tutorial_steps: Vec<TutorialStep>,

    #[schemars(title = "Настройки чатов")]
    pub chats_settings: Vec<ChatSettings>,

    #[schemars(title = "Шаблоны офферов")]
    pub offers_templates: Vec<OfferTemplate>,

    #[schemars(title = "Вкладки магазина")]
    pub shop_tabs: Vec<ShopTabConfig>,

    #[schemars(title = "Настройки рейтингов")]
    pub ratings_settings: Vec<RatingSettings>,

    #[schemars(title = "Набор скриптов для читов")]
    pub cheat_scripts: Vec<CheatScript>,

    #[schemars(
        title = "Скрипты генерации тестового игрока",
        description = "Используется только в режиме читов. Каждый скрипт в формате TestPlayerResult — задаёт предметы, способности, петов, уровень, класс и силу тестового игрока. Выбирается по индексу."
    )]
    pub test_player_scripts: Vec<TestPlayerScript>,

    #[schemars(title = "Гейтинги")]
    pub gatings: Gatings,

    #[schemars(title = "Шаблоны петов")]
    pub pet_templates: Vec<PetTemplate>,

    #[schemars(title = "Редкости петов")]
    pub pet_rarities: Vec<PetRarity>,

    #[schemars(title = "Уровни петов")]
    pub pet_levels: Vec<PetLevel>,

    #[schemars(title = "Уровни слотов петов")]
    pub pet_slots_levels: Vec<PetSlotsLevel>,

    #[schemars(title = "Настройки сундука-гачи-петов")]
    pub pet_cases_settings: Vec<PetCasesSettingsByLevel>,

    #[schemars(title = "Настройки дерева талантов")]
    pub talent_tree_settings: TalentTreeSettings,

    #[schemars(title = "Таланты")]
    pub talents: Vec<TalentTemplate>,

    #[schemars(title = "Грейды бонусов статуи")]
    pub statue_bonus_grades: NonEmptyVec<StatueBonusGrade>,

    #[schemars(title = "Типы бонусов статуи (стат × грейд)")]
    pub statue_bonus_type_configs: NonEmptyVec<StatueBonusTypeConfig>,

    #[schemars(title = "Таблица уровней статуи")]
    pub statue_level_configs: NonEmptyVec<StatueLevelConfig>,

    #[schemars(title = "Настройки статуи героя")]
    pub statue_settings: StatueSettings,

    #[schemars(title = "Шаблоны баффов")]
    pub buff_templates: Vec<BuffTemplate>,

    #[schemars(title = "Настройки прогресс пасса")]
    pub progress_pass: ProgressPassConfig,

    #[schemars(title = "Варианты рекламных птиц")]
    pub bird_variants: Vec<BirdVariant>,

    #[schemars(title = "Настройки мини-игры Plinko")]
    pub plinko_settings: PlinkoSettings,

    /// Texts and timings for OS-level notifications the client schedules on the
    /// device itself. Nothing here is sent from the server at runtime.
    #[schemars(title = "Настройки локальных уведомлений на телефоне")]
    pub local_notifications: LocalNotificationsSettings,
}

impl std::fmt::Debug for GameConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "GameConfig")
    }
}

/// One authored Power coefficient pair (BAL-030). A `q` below `1` would make a
/// component LOWER displayed Power, which the estimator never does — a weak or
/// no-op component is worth exactly `1` — and a max rank below the first would
/// mean upgrading a component made it look weaker.
fn validate_power_q(what: &str, first_rank: f64, max_rank: f64) {
    assert!(
        first_rank.is_finite() && max_rank.is_finite(),
        "{what}: power q must be finite"
    );
    assert!(
        first_rank >= 1.0,
        "{what}: power q at the first rank must be >= 1.0, got {first_rank}"
    );
    assert!(
        max_rank >= first_rank,
        "{what}: power q must not shrink with rank ({first_rank} -> {max_rank})"
    );
}

impl GameConfig {
    /// Whether the ability is a class active (referenced by any class's
    /// `class_abilities`). Class abilities are level-capped below regular ones
    /// and use their own ability-stone socket ladder.
    pub fn is_class_ability(&self, ability_id: essences::abilities::AbilityId) -> bool {
        self.classes
            .iter()
            .any(|class| class.class_abilities.contains(&ability_id))
    }

    pub fn clone_translate(&self, translator: &i18n::translator::Translator, locale: &str) -> Self {
        let mut config = self.clone();
        for ability in &mut config.abilities {
            ability.name = translator.translate(&ability.name, locale);
            ability.description = translator.translate(&ability.description, locale);
        }

        for attribute in &mut config.attributes {
            attribute.name = translator.translate(&attribute.name, locale);
            attribute.description = translator.translate(&attribute.description, locale);
            if let Some(prefix) = &attribute.prefix {
                attribute.prefix = Some(translator.translate(prefix, locale));
            }
            if let Some(suffix) = &attribute.suffix {
                attribute.suffix = Some(translator.translate(suffix, locale));
            }
        }

        for effect in &mut config.effects {
            effect.name = translator.translate(&effect.name, locale);
        }

        for event in &mut config.event_descriptions {
            event.description = translator.translate(&event.description, locale);
        }

        for item in &mut config.items {
            item.name = translator.translate(&item.name, locale);
        }

        for item_rarity in &mut config.item_rarities {
            item_rarity.name = translator.translate(&item_rarity.name, locale);
        }

        for skin in &mut config.skins {
            skin.name = translator.translate(&skin.name, locale);
        }

        for ability_rarity in &mut config.ability_rarities {
            ability_rarity.name = translator.translate(&ability_rarity.name, locale);
        }

        for ability_stone in &mut config.ability_stones {
            ability_stone.name = translator.translate(&ability_stone.name, locale);
            ability_stone.description = translator.translate(&ability_stone.description, locale);
        }

        for quest in &mut config.quests {
            quest.title = translator.translate(&quest.title, locale);
            quest.description = translator.translate(&quest.description, locale);
        }

        for vassal_task in &mut config.vassal_tasks {
            vassal_task.title = translator.translate(&vassal_task.title, locale);
        }

        for currency in &mut config.currencies {
            currency.name = translator.translate(&currency.name, locale);
            currency.description = translator.translate(&currency.description, locale);
        }

        for mail_template in &mut config.mail_templates {
            mail_template.title = translator.translate(&mail_template.title, locale);
            mail_template.message = translator.translate(&mail_template.message, locale);
        }

        for league in &mut config.arena_leagues {
            league.name = translator.translate(&league.name, locale);
        }

        for fight in &mut config.fight_templates {
            fight.title = translator.translate(&fight.title, locale);
        }

        for class in &mut config.classes {
            class.name = translator.translate(&class.name, locale);
            class.description = translator.translate(&class.description, locale);
            class.weapon_type = translator.translate(&class.weapon_type, locale);
        }

        for dungeon in &mut config.dungeon_templates {
            dungeon.title = translator.translate(&dungeon.title, locale);
            dungeon.description = translator.translate(&dungeon.description, locale);

            for tip in &mut dungeon.tips {
                tip.tip = translator.translate(&tip.tip, locale);
            }
        }

        for step in &mut config.tutorial_steps {
            step.text = translator.translate(&step.text, locale);
        }

        for offer in &mut config.offers_templates {
            offer.title = translator.translate(&offer.title, locale);
            if let Some(limit_buy_text) = &offer.limit_buy_text {
                offer.limit_buy_text = Some(translator.translate(limit_buy_text, locale));
            }
        }

        for shop_tab in &mut config.shop_tabs {
            shop_tab.name = translator.translate(&shop_tab.name, locale);
        }

        for chapter in &mut config.chapters {
            chapter.title = translator.translate(&chapter.title, locale);
        }

        for pet_template in &mut config.pet_templates {
            pet_template.name = translator.translate(&pet_template.name, locale);
        }

        for pet_rarity in &mut config.pet_rarities {
            pet_rarity.name = translator.translate(&pet_rarity.name, locale);
        }

        for talent in &mut config.talents {
            talent.name = translator.translate(&talent.name, locale);
            talent.description = translator.translate(&talent.description, locale);
        }

        for law in &mut config.laws {
            law.name = translator.translate(&law.name, locale);
            law.description = translator.translate(&law.description, locale);
        }

        config.ability_presets_settings.default_preset_name =
            translator.translate(&config.ability_presets_settings.default_preset_name, locale);

        for grade in &mut config.statue_bonus_grades {
            grade.name = translator.translate(&grade.name, locale);
        }

        for buff in &mut config.buff_templates {
            buff.title = translator.translate(&buff.title, locale);
            buff.description = translator.translate(&buff.description, locale);
        }

        for skin in &mut config.skins {
            if let Some(unlock_description) = &skin.unlock_description {
                skin.unlock_description = Some(translator.translate(unlock_description, locale));
            }
        }

        for trigger_stone in &mut config.trigger_stones {
            trigger_stone.name = translator.translate(&trigger_stone.name, locale);
            trigger_stone.description = translator.translate(&trigger_stone.description, locale);
        }

        for effect_stone in &mut config.effect_stones {
            effect_stone.name = translator.translate(&effect_stone.name, locale);
            effect_stone.description = translator.translate(&effect_stone.description, locale);
        }

        for artifact in &mut config.artifacts {
            artifact.name = translator.translate(&artifact.name, locale);
            artifact.description = translator.translate(&artifact.description, locale);
        }

        for artifact_stone in &mut config.artifact_stones {
            artifact_stone.name = translator.translate(&artifact_stone.name, locale);
            artifact_stone.description = translator.translate(&artifact_stone.description, locale);
        }

        {
            let notifications = &mut config.local_notifications;
            let translate_text = |text: &mut crate::local_notifications::LocalNotificationText| {
                text.title = translator.translate(&text.title, locale);
                text.body = translator.translate(&text.body, locale);
            };

            for step in &mut notifications.win_back {
                translate_text(&mut step.text);
            }
            translate_text(&mut notifications.afk_rewards_capped);
            translate_text(&mut notifications.item_case_upgrade_finished);
            translate_text(&mut notifications.talent_upgrade_finished);
            translate_text(&mut notifications.daily_reset);
            translate_text(&mut notifications.boost_expiring);
        }

        config
    }

    pub fn validate(&self) {
        // TODO: Also check empty vectors, too big numbers, invalid references, 0 div
        if !Self::has_unique_ids(&self.items) {
            panic!("Not unique item ids in config");
        }
        self.validate_portal_rarities();
        self.validate_item_world_sides();
        self.validate_flip_settings();
        self.validate_local_notifications();
        self.validate_mana_settings();
        self.validate_ability_stone_settings();
        self.validate_cores_settings();
        self.validate_pet_facet_settings();
        self.validate_stones();
        self.validate_artifacts();
        self.validate_collection_power();
        self.validate_inventory_levels();

        self.validate_ability_gacha_settings();

        Self::validate_afk_rewards(
            &self.afk_rewards_levels,
            &self.afk_rewards_settings,
            &self.currencies,
            &self.abilities,
            &self.items,
            &self.bundles,
        );
        Self::validate_loop_task_chain(&self.quests);
        self.validate_pet_config();
        self.validate_pet_gacha_settings();
        self.validate_statue_settings();
        self.validate_class_levels();
        self.validate_class_abilities();
        self.validate_item_cases_settings();
        self.validate_dungeon_templates();
        self.validate_rating_rewards();
        Self::validate_progress_pass_config(&self.progress_pass);
        self.validate_progress_pass_references();
        self.validate_plinko_settings();
        self.validate_power_estimator_settings();
    }

    fn validate_dungeon_templates(&self) {
        for dungeon in &self.dungeon_templates {
            if dungeon.between_wave_spawn_delay_ticks == Some(0) {
                panic!(
                    "DungeonTemplate {}: between_wave_spawn_delay_ticks must be > 0 when set",
                    dungeon.id
                );
            }
        }
    }

    /// BAL-030: the three scalars the `P_ui` estimator needs beyond the
    /// per-template coefficients.
    fn validate_power_estimator_settings(&self) {
        let settings = &self.game_settings.power_estimator;
        assert!(
            settings.reference_trigger_proc_rate.is_finite()
                && settings.reference_trigger_proc_rate > 0.0,
            "PowerEstimatorSettings: reference_trigger_proc_rate must be finite and > 0 — it              divides every authored trigger frequency"
        );
        assert!(
            settings.trigger_only_q >= 1.0,
            "PowerEstimatorSettings: trigger_only_q must be >= 1.0"
        );
        assert!(
            (0.0..=1.0).contains(&settings.bridge_expected_fill),
            "PowerEstimatorSettings: bridge_expected_fill is a share of capacity, so it must be              within 0..=1"
        );
    }

    /// Инварианты доски Plinko. Сервер катит путь и начисляет статы по этой
    /// таблице, поэтому кривая раскладка означала бы шарик, приземлившийся в
    /// слот с чужой подписью, или бонус без потолка.
    fn validate_plinko_settings(&self) {
        use std::collections::HashSet;

        let plinko = &self.plinko_settings;
        if plinko.rows < MIN_PLINKO_ROWS || plinko.rows > MAX_PLINKO_ROWS {
            panic!(
                "plinko_settings.rows = {} is outside {MIN_PLINKO_ROWS}..={MAX_PLINKO_ROWS}",
                plinko.rows
            );
        }

        let mut seen_levels = HashSet::new();
        for layout in plinko.slot_layouts.iter() {
            if !seen_levels.insert(layout.chest_level) {
                panic!(
                    "plinko_settings.slot_layouts has two layouts for chest level {}",
                    layout.chest_level
                );
            }
            if !self
                .item_cases_settings
                .iter()
                .any(|settings| settings.level == layout.chest_level)
            {
                panic!(
                    "plinko_settings.slot_layouts has a layout for chest level {}, which has no item_cases_settings",
                    layout.chest_level
                );
            }

            let mut groups: Vec<_> = layout.slot_groups.iter().collect();
            groups.sort_by_key(|group| group.from_slot);
            let mut expected_from = 0;
            for group in &groups {
                if group.from_slot != expected_from || group.to_slot < group.from_slot {
                    panic!(
                        "plinko_settings.slot_layouts chest level {} must cover slots 0..={} without gaps or overlaps, got group {}..{}",
                        layout.chest_level, plinko.rows, group.from_slot, group.to_slot
                    );
                }
                if !self.item_rarities.iter().any(|r| r.id == group.rarity_id) {
                    panic!(
                        "plinko_settings.slot_layouts chest level {} references unknown item rarity {}",
                        layout.chest_level, group.rarity_id
                    );
                }
                expected_from = group.to_slot + 1;
            }
            if expected_from != plinko.slot_count() {
                panic!(
                    "plinko_settings.slot_layouts chest level {} covers {expected_from} slots, expected {}",
                    layout.chest_level,
                    plinko.slot_count()
                );
            }
        }

        self.validate_plinko_rarity_coverage();

        let mut seen_pins = HashSet::new();
        for bonus in &plinko.pin_bonuses {
            if bonus.row < 0 || bonus.row >= plinko.rows {
                panic!(
                    "plinko_settings.pin_bonuses row {} is outside 0..{}",
                    bonus.row, plinko.rows
                );
            }
            if bonus.column < 0 || bonus.column > bonus.row {
                panic!(
                    "plinko_settings.pin_bonuses column {} is outside 0..={} for row {}",
                    bonus.column, bonus.row, bonus.row
                );
            }
            if !seen_pins.insert((bonus.row, bonus.column)) {
                panic!(
                    "plinko_settings.pin_bonuses has duplicate pin ({}, {})",
                    bonus.row, bonus.column
                );
            }
            if bonus.value <= 0 {
                panic!(
                    "plinko_settings.pin_bonuses pin ({}, {}) has non-positive value {}",
                    bonus.row, bonus.column, bonus.value
                );
            }
            if !self.attributes.iter().any(|a| a.id == bonus.attribute_id) {
                panic!(
                    "plinko_settings.pin_bonuses references unknown attribute {}",
                    bonus.attribute_id
                );
            }
        }

        // BAL-021: every axis of the pin table needs a tranche on EVERY chest
        // level, or a level would silently stop paying that axis.
        let axes: HashSet<_> = plinko.pin_bonuses.iter().map(|p| p.attribute_id).collect();
        let mut seen_levels = HashSet::new();
        let mut previous: std::collections::HashMap<uuid::Uuid, i64> =
            std::collections::HashMap::new();
        let mut levels: Vec<_> = plinko.tranches.iter().collect();
        levels.sort_by_key(|tranche| tranche.chest_level);
        for tranche in levels {
            if !seen_levels.insert(tranche.chest_level) {
                panic!(
                    "plinko_settings.tranches has two rows for chest level {}",
                    tranche.chest_level
                );
            }
            let mut seen_axes = HashSet::new();
            for axis in &tranche.axes {
                if !seen_axes.insert(axis.attribute_id) {
                    panic!(
                        "plinko_settings.tranches chest level {} lists attribute {} twice",
                        tranche.chest_level, axis.attribute_id
                    );
                }
                assert!(
                    axis.cap_micro >= 0 && axis.scale_micro >= 0,
                    "plinko_settings.tranches chest level {}: attribute {} has a negative cap or                      scale",
                    tranche.chest_level,
                    axis.attribute_id
                );
                let last = previous.entry(axis.attribute_id).or_insert(0);
                assert!(
                    axis.cap_micro >= *last,
                    "plinko_settings.tranches chest level {}: the cap of attribute {} shrinks                      ({last} -> {}) — a chest upgrade must never take accumulated stats away",
                    tranche.chest_level,
                    axis.attribute_id,
                    axis.cap_micro
                );
                *last = axis.cap_micro;
            }
            for axis in &axes {
                assert!(
                    seen_axes.contains(axis),
                    "plinko_settings.tranches chest level {} has no row for attribute {}, which                      the pin table pays",
                    tranche.chest_level,
                    axis
                );
            }
        }

        for settings in &self.item_cases_settings {
            assert!(
                seen_levels.contains(&settings.level),
                "plinko_settings.tranches has no row for chest level {}",
                settings.level
            );
        }
    }

    /// Каждая редкость, выпадающая на уровне сундука, обязана иметь слот в
    /// раскладке ЭТОГО уровня, и у каждого уровня сундука обязана быть
    /// раскладка.
    ///
    /// Раньше это было предупреждением: раскладка была одна на всю игру, а
    /// набор выпадающих редкостей растёт с уровнем сундука, поэтому полное
    /// покрытие было недостижимо и шарик ронялся в слот с ближайшей меньшей
    /// подписью. С раскладкой на уровень покрытие достижимо, поэтому
    /// несоответствие — сломанный конфиг: сервер не сможет выбрать слот и
    /// открытие сундука останется без шарика.
    fn validate_plinko_rarity_coverage(&self) {
        for settings in &self.item_cases_settings {
            let Some(layout) = self.plinko_settings.layout_for_level(settings.level) else {
                panic!(
                    "plinko_settings.slot_layouts has no board for chest level {}",
                    settings.level
                );
            };

            for weight in &settings.rarity_weights {
                if weight.weight <= 0.0 {
                    continue;
                }
                if layout.slots_for_rarity(weight.rarity_id).is_empty() {
                    panic!(
                        "plinko_settings.slot_layouts chest level {} has no slot for item rarity {}, \
                         which drops there with weight {}",
                        settings.level, weight.rarity_id, weight.weight
                    );
                }
            }
        }

        self.validate_plinko_layout_monotonicity();
    }

    /// Тир не убывает от центра доски к краям — по обеим половинам, и обе
    /// центральные ячейки несут один и тот же тир.
    ///
    /// Игрок читает доску как «к краям редкость растёт», поэтому раскладка, в
    /// которой более высокий тир оказался ближе к центру, чем более низкий,
    /// врёт ему. Позиция слота вообще не связана с вероятностью: путь строится
    /// к заранее выбранному слоту (`CreateToSlot`), попасть в край не
    /// «труднее», чем в центр, — поэтому единственный ключ раскладки — тир.
    ///
    /// Проверка живёт в валидации, а не в тесте: `validate` вызывается при
    /// загрузке конфига, и CI прогоняет `config_validator` по боевым
    /// конфигам, так что немонотонная раскладка не доедет до игрока.
    fn validate_plinko_layout_monotonicity(&self) {
        use std::collections::HashSet;

        let plinko = &self.plinko_settings;
        let order_of = |rarity_id: uuid::Uuid| {
            self.item_rarities
                .iter()
                .find(|rarity| rarity.id == rarity_id)
                .map(|rarity| rarity.order)
                .unwrap_or_else(|| {
                    panic!(
                        "plinko_settings.slot_layouts references unknown item rarity {rarity_id}"
                    )
                })
        };

        // При чётном числе слотов центр — пара, при нечётном обе половины
        // растут от одной и той же средней ячейки.
        let left_centre = (plinko.slot_count() - 1) / 2;
        let right_centre = plinko.slot_count() / 2;

        for layout in plinko.slot_layouts.iter() {
            let tier = |slot: i64| {
                let rarity = layout.rarity_for_slot(slot).unwrap_or_else(|| {
                    panic!(
                        "plinko_settings.slot_layouts chest level {} has no label for slot {slot}",
                        layout.chest_level
                    )
                });
                order_of(rarity)
            };

            // Пара в центре несёт один тир — кроме вырожденного случая, когда
            // редкостей ровно столько же, сколько слотов: тогда пар не
            // остаётся вовсе и каждый слот подписан своим тиром.
            let distinct: HashSet<_> = layout
                .slot_groups
                .iter()
                .map(|group| group.rarity_id)
                .collect();
            let has_pairs = (distinct.len() as i64) < plinko.slot_count();
            if has_pairs && left_centre != right_centre && tier(left_centre) != tier(right_centre) {
                panic!(
                    "plinko_settings.slot_layouts chest level {}: the centre slots {left_centre} \
                     and {right_centre} carry different tiers ({} and {})",
                    layout.chest_level,
                    tier(left_centre),
                    tier(right_centre)
                );
            }

            for slot in (1..=left_centre).rev() {
                if tier(slot - 1) < tier(slot) {
                    panic!(
                        "plinko_settings.slot_layouts chest level {}: slot {} carries tier {}, \
                         lower than tier {} on slot {slot} closer to the centre — the tier must \
                         not drop towards the edge",
                        layout.chest_level,
                        slot - 1,
                        tier(slot - 1),
                        tier(slot)
                    );
                }
            }
            for slot in right_centre..plinko.rows {
                if tier(slot + 1) < tier(slot) {
                    panic!(
                        "plinko_settings.slot_layouts chest level {}: slot {} carries tier {}, \
                         lower than tier {} on slot {slot} closer to the centre — the tier must \
                         not drop towards the edge",
                        layout.chest_level,
                        slot + 1,
                        tier(slot + 1),
                        tier(slot)
                    );
                }
            }
        }
    }

    /// Rating reward invariants keep the cron and reward-screen claim path
    /// data-driven and safe to run without runtime fallbacks.
    fn validate_rating_rewards(&self) {
        use essences::{
            bundles::BundleStepType,
            ratings::{RatingRangeReward, RatingType},
        };
        use std::collections::{HashMap, HashSet};

        fn validate_ranges(label: &str, ranges: &[RatingRangeReward]) {
            let mut sorted = ranges.to_vec();
            sorted.sort_by_key(|range| range.diapason_start);
            let mut previous_end = 0;
            for range in sorted {
                assert!(
                    range.diapason_start >= 1,
                    "{label}: diapason_start must be at least 1"
                );
                let end = range.diapason_end.unwrap_or(i64::MAX);
                assert!(
                    end >= range.diapason_start,
                    "{label}: diapason_end must not precede diapason_start"
                );
                assert!(
                    range.diapason_start > previous_end,
                    "{label}: reward ranges must not overlap"
                );
                previous_end = end;
            }
        }

        fn fixed_currencies(
            label: &str,
            bundle: &essences::bundles::BundleRaw,
            currency_only: bool,
        ) -> HashMap<uuid::Uuid, i64> {
            let mut totals = HashMap::new();
            for step in &bundle.steps {
                if step.item_type != BundleStepType::Currency {
                    assert!(
                        !currency_only,
                        "{label}: daily bundle must be currency-only"
                    );
                    continue;
                }
                assert!(
                    step.behavior.is_none() && step.currency_branch.is_none(),
                    "{label}: rating reward currencies must be fixed"
                );
                for unit in &step.currencies {
                    assert!(unit.amount > 0, "{label}: currency amount must be positive");
                    *totals.entry(unit.currency_id).or_insert(0) += unit.amount;
                }
            }
            assert!(!totals.is_empty(), "{label}: bundle must contain currency");
            totals
        }

        let mut seen_types = HashSet::new();
        for settings in &self.ratings_settings {
            assert!(
                seen_types.insert(settings.rating_type.clone()),
                "Duplicate RatingSettings for {:?}",
                settings.rating_type
            );

            let label = format!("{:?} weekly rating rewards", settings.rating_type);
            validate_ranges(&label, &settings.weekly_rating_range_rewards);
            let daily_label = format!("{:?} daily rating rewards", settings.rating_type);
            validate_ranges(&daily_label, &settings.daily_rating_range_rewards);

            if settings.rating_type == RatingType::Power {
                assert!(
                    settings.daily_rating_range_rewards.is_empty()
                        && settings.weekly_rating_range_rewards.is_empty(),
                    "Power rating rewards must be empty"
                );
            }

            for weekly in &settings.weekly_rating_range_rewards {
                assert!(
                    self.bundles
                        .iter()
                        .any(|bundle| bundle.id == weekly.bundle_id),
                    "{label}: unknown bundle {}",
                    weekly.bundle_id
                );
                if let Some(mail_template_id) = weekly.legacy_mail_template_id {
                    assert!(
                        self.mail_templates
                            .iter()
                            .any(|template| template.id == mail_template_id),
                        "{label}: unknown legacy mail template {mail_template_id}"
                    );
                }
            }

            for daily in &settings.daily_rating_range_rewards {
                let daily_bundle = self
                    .bundles
                    .iter()
                    .find(|bundle| bundle.id == daily.bundle_id)
                    .unwrap_or_else(|| panic!("{daily_label}: unknown bundle {}", daily.bundle_id));
                assert!(
                    daily.legacy_mail_template_id.is_none(),
                    "{daily_label}: daily rewards must not reference mail templates"
                );
                let daily_currencies = fixed_currencies(&daily_label, daily_bundle, true);

                let weekly = settings
                    .weekly_rating_range_rewards
                    .iter()
                    .find(|weekly| {
                        weekly.diapason_start == daily.diapason_start
                            && weekly.diapason_end == daily.diapason_end
                    })
                    .unwrap_or_else(|| {
                        panic!(
                            "{daily_label}: range {}..{:?} has no corresponding weekly range",
                            daily.diapason_start, daily.diapason_end
                        )
                    });
                let weekly_bundle = self
                    .bundles
                    .iter()
                    .find(|bundle| bundle.id == weekly.bundle_id)
                    .expect("weekly bundle reference validated above");
                let weekly_currencies = fixed_currencies(&label, weekly_bundle, false);

                assert_eq!(
                    weekly_currencies.len(),
                    daily_currencies.len(),
                    "{daily_label}: daily currencies must exactly match weekly currencies"
                );
                for (currency_id, weekly_amount) in weekly_currencies {
                    let daily_amount = daily_currencies.get(&currency_id).copied().unwrap_or(0);
                    assert_eq!(
                        weekly_amount,
                        daily_amount * 5,
                        "{daily_label}: currency {currency_id} must be exactly 1:5 of weekly"
                    );
                }
            }
        }

        for rating_type in [RatingType::Arena, RatingType::Power, RatingType::PvE] {
            assert!(
                seen_types.contains(&rating_type),
                "Missing RatingSettings for {rating_type:?}"
            );
        }
    }

    /// Per-class invariants for `Class.class_abilities`:
    ///  - disjoint from that class's `basic_abilities`;
    ///  - every referenced ability template exists and has `is_gacha_ability == false`
    ///    (class actives must never drop from the gacha pool per the design doc).
    fn validate_class_abilities(&self) {
        use std::collections::HashSet;

        for class in &self.classes {
            validate_power_q(
                &format!("Class {} passive", class.id),
                class.passive_power_q_l1,
                class.passive_power_q_l20,
            );
            for row in &class.ability_power_q {
                validate_power_q(
                    &format!("Class {} ability {} q", class.id, row.ability_id),
                    row.q,
                    row.q,
                );
            }
            let basics: HashSet<_> = class.basic_abilities.iter().copied().collect();
            let mut seen = HashSet::new();
            for ability_id in &class.class_abilities {
                if !seen.insert(*ability_id) {
                    panic!(
                        "Class {}: duplicate ability_id {ability_id} in class_abilities",
                        class.id
                    );
                }
                if basics.contains(ability_id) {
                    panic!(
                        "Class {}: ability {ability_id} appears in both basic_abilities and class_abilities",
                        class.id
                    );
                }
                let Some(template) = self.abilities.iter().find(|a| a.id == *ability_id) else {
                    panic!(
                        "Class {}: class_abilities references unknown ability_id {ability_id}",
                        class.id
                    );
                };
                if template.is_gacha_ability {
                    panic!(
                        "Class {}: class_ability {ability_id} has is_gacha_ability=true; class actives must be excluded from the gacha pool",
                        class.id
                    );
                }
            }
        }
    }

    fn validate_class_levels(&self) {
        use std::collections::HashMap;

        let mut by_class: HashMap<class::ClassId, Vec<u64>> = HashMap::new();
        for row in &self.class_levels {
            by_class.entry(row.class_id).or_default().push(row.level);
        }

        for (class_id, mut levels) in by_class {
            levels.sort();
            let mut dedup = levels.clone();
            dedup.dedup();
            if dedup.len() != levels.len() {
                panic!("ClassLevels for class {class_id}: duplicate level entries");
            }
            for (i, level) in levels.iter().enumerate() {
                let expected = (i as u64) + 1;
                if *level != expected {
                    panic!(
                        "ClassLevels for class {class_id}: expected contiguous levels starting at 1, got {level} at position {expected}"
                    );
                }
            }
        }

        // BAL-034: Class Level is one shared account ladder, so a level costs
        // the same whatever class the player raised it from. Diverging prices
        // would make the shared level cheaper or dearer depending on which
        // screen the button was pressed on.
        let mut price_of_level: HashMap<u64, &essences::currency::CurrencyUnit> = HashMap::new();
        for row in &self.class_levels {
            match price_of_level.get(&row.level) {
                None => {
                    price_of_level.insert(row.level, &row.price);
                }
                Some(first) => assert!(
                    first.currency_id == row.price.currency_id && first.amount == row.price.amount,
                    "ClassLevels level {}: class {} prices it {} x{} while another class prices it \
                     {} x{} — the ladder is shared, so the price must be too",
                    row.level,
                    row.class_id,
                    row.price.currency_id,
                    row.price.amount,
                    first.currency_id,
                    first.amount
                ),
            }
        }
    }

    /// The auto-chest batch cap (`auto_chest_settings.max_batch_size`) is the
    /// most chests a player may auto-open in a single batch at a given chest
    /// level. Chests only ever get upgraded, so the cap must never step down as
    /// the level rises — a decrease would silently shrink a capability the
    /// player already had. Enforce a monotonic non-decreasing sequence ordered
    /// by chest level.
    fn validate_item_cases_settings(&self) {
        let mut by_level: Vec<&ItemCasesSettingsByLevel> =
            self.item_cases_settings.iter().collect();
        by_level.sort_by_key(|s| s.level);

        for pair in by_level.windows(2) {
            let (prev, next) = (pair[0], pair[1]);
            for (label, prev_cap, next_cap) in [
                (
                    "max_batch_size",
                    prev.auto_chest_settings.max_batch_size,
                    next.auto_chest_settings.max_batch_size,
                ),
                (
                    "auto_only_max_batch_size",
                    prev.auto_chest_settings.auto_only_max_batch_size,
                    next.auto_chest_settings.auto_only_max_batch_size,
                ),
            ] {
                if next_cap < prev_cap {
                    panic!(
                        "ItemCasesSettings: auto_chest {label} must never decrease with chest \
                         level, but drops from {prev_cap} at level {} to {next_cap} at level {}",
                        prev.level, next.level,
                    );
                }
            }
            // The auto ladder is deliberately the tighter of the two: auto runs
            // continuously, so its throughput is capped harder than a manual
            // tap. A config where auto exceeds manual would silently make the
            // automatic path the faster one.
            if next.auto_chest_settings.auto_only_max_batch_size
                > next.auto_chest_settings.max_batch_size
            {
                panic!(
                    "ItemCasesSettings: auto_only_max_batch_size ({}) must not exceed \
                     max_batch_size ({}) at level {}",
                    next.auto_chest_settings.auto_only_max_batch_size,
                    next.auto_chest_settings.max_batch_size,
                    next.level,
                );
            }
        }
    }

    /// Portal rarity mappings must remain a one-to-one projection of existing
    /// item rarities, must cover every rarity rendered by a Plinko board, and
    /// must always carry a renderable Unity asset address.
    fn validate_portal_rarities(&self) {
        use std::collections::HashSet;

        let item_rarity_ids: HashSet<_> =
            self.item_rarities.iter().map(|rarity| rarity.id).collect();
        let mut portal_rarity_ids = HashSet::new();
        let mut mapped_item_rarity_ids = HashSet::new();

        for portal_rarity in &self.portal_rarities {
            assert!(
                portal_rarity_ids.insert(portal_rarity.id),
                "PortalRarities: duplicate id {}",
                portal_rarity.id
            );
            assert!(
                mapped_item_rarity_ids.insert(portal_rarity.item_rarity_id),
                "PortalRarities: duplicate item_rarity_id {}",
                portal_rarity.item_rarity_id
            );
            assert!(
                item_rarity_ids.contains(&portal_rarity.item_rarity_id),
                "PortalRarities: item_rarity_id {} not found in item_rarities",
                portal_rarity.item_rarity_id
            );
            assert!(
                !portal_rarity.icon_path.trim().is_empty(),
                "PortalRarities: icon_path must not be empty for {}",
                portal_rarity.id
            );
        }

        for rarity_id in self
            .plinko_settings
            .slot_layouts
            .iter()
            .flat_map(|layout| layout.slot_groups.iter())
            .map(|group| group.rarity_id)
        {
            assert!(
                mapped_item_rarity_ids.contains(&rarity_id),
                "PortalRarities: missing mapping for item rarity {rarity_id} referenced by plinko_settings.slot_layouts"
            );
        }
    }

    fn validate_flip_settings(&self) {
        assert!(
            self.flip_settings.unlock_chapter >= 0,
            "FlipSettings: unlock_chapter must be >= 0"
        );
        assert!(
            self.flip_settings.progress_threshold.is_finite()
                && self.flip_settings.progress_threshold > 0.0,
            "FlipSettings: progress_threshold must be finite and > 0"
        );
        assert!(
            self.flip_settings.damage_gauge_coefficient.is_finite()
                && self.flip_settings.damage_gauge_coefficient >= 0.0,
            "FlipSettings: damage_gauge_coefficient must be finite and >= 0"
        );
    }

    fn validate_local_notifications(&self) {
        let settings = &self.local_notifications;
        assert!(
            settings.quiet_hours_start < 24,
            "LocalNotificationsSettings: quiet_hours_start must be 0..=23"
        );
        assert!(
            settings.quiet_hours_end < 24,
            "LocalNotificationsSettings: quiet_hours_end must be 0..=23"
        );

        let mut previous = 0u64;
        for step in &settings.win_back {
            let delay = step.delay_minutes.get();
            assert!(
                delay > previous,
                "LocalNotificationsSettings: win_back delays must strictly increase, got {delay} after {previous}"
            );
            previous = delay;
        }
    }

    fn validate_mana_settings(&self) {
        assert!(
            self.mana_settings.pool.is_finite() && self.mana_settings.pool > 0.0,
            "ManaSettings: pool must be finite and > 0"
        );
        assert!(
            self.mana_settings.regen_per_second.is_finite()
                && self.mana_settings.regen_per_second >= 0.0,
            "ManaSettings: regen_per_second must be finite and >= 0"
        );
        for ability in &self.abilities {
            assert!(
                ability.mana_cost >= 0,
                "Ability {} has a negative mana_cost",
                ability.id
            );
        }
    }

    fn validate_ability_stone_settings(&self) {
        use std::collections::HashSet;

        let settings = &self.ability_stone_settings;
        assert!(
            settings.unlock_chapter >= 0,
            "AbilityStoneSettings: unlock_chapter must be >= 0"
        );
        for (name, sockets) in [
            ("sockets", &settings.sockets),
            ("class_sockets", &settings.class_sockets),
        ] {
            assert!(
                !sockets.is_empty(),
                "AbilityStoneSettings: {name} must not be empty"
            );
            for (index, socket) in sockets.iter().enumerate() {
                assert!(
                    socket.unlock_ability_level >= 1,
                    "AbilityStoneSettings: {name}[{index}] unlock_ability_level must be >= 1"
                );
            }
        }
        assert!(
            !settings.upgrade_copies.is_empty(),
            "AbilityStoneSettings: upgrade_copies must not be empty"
        );
        for (index, copies) in settings.upgrade_copies.iter().enumerate() {
            assert!(
                *copies > 0,
                "AbilityStoneSettings: upgrade_copies[{index}] must be > 0"
            );
        }
        assert!(
            settings.chapter_reward_period >= 0,
            "AbilityStoneSettings: chapter_reward_period must be >= 0"
        );

        let mut ids = HashSet::new();
        for stone in &self.ability_stones {
            assert!(
                ids.insert(stone.id),
                "Not unique ability stone id {} in config",
                stone.id
            );
            validate_power_q(
                &format!("AbilityStoneTemplate {}", stone.id),
                stone.power_q_first_rank,
                stone.power_q_max_rank,
            );
            assert!(
                !stone.ops.is_empty(),
                "Ability stone {} carries no operations",
                stone.id
            );
            for op in &stone.ops {
                assert!(
                    op.base_value.is_finite() && op.value_per_level.is_finite(),
                    "Ability stone {} has a non-finite value in op {}",
                    stone.id,
                    op.kind
                );
                assert!(
                    op.count >= 0 && op.interval_ms >= 0,
                    "Ability stone {} has a negative count/interval in op {}",
                    stone.id,
                    op.kind
                );
            }
        }
        if settings.chapter_reward_period > 0 {
            assert!(
                !self.ability_stones.is_empty(),
                "AbilityStoneSettings: chapter rewards are enabled but the stone catalog is empty"
            );
        }
    }

    /// Pet Facets: the invariants a facet cannot survive being wrong about.
    ///
    /// Only the numbers a facet DIVIDES by, COUNTS with or schedules an expiry
    /// on are asserted. A magnitude of zero is a legitimate "switch this facet
    /// off" tuning, but a zero duration would leave a timed buff permanent
    /// (`apply_timed_attribute` refuses one at runtime, and this stops it
    /// reaching the runtime at all), and a zero charge count would arm a facet
    /// that can never spend.
    fn validate_pet_facet_settings(&self) {
        let settings = &self.pet_facet_settings;
        assert!(
            settings.rank_growth_permyriad >= 0,
            "PetFacetSettings: rank_growth_permyriad must be >= 0"
        );

        // BAL-030: every facet carries a Power row, so a facet added later
        // cannot silently read as "worth nothing" in displayed Power.
        {
            use strum::IntoEnumIterator;
            for facet in essences::pet_facets::PetFacet::iter() {
                let row = settings.power_q_row(facet).unwrap_or_else(|| {
                    panic!("PetFacetSettings: facet {facet:?} has no power_q row")
                });
                validate_power_q(
                    &format!("PetFacetSettings::power_q[{facet:?}]"),
                    row.q_first_level,
                    row.q_max_level,
                );
            }
            assert_eq!(
                settings.power_q.len(),
                essences::pet_facets::PetFacet::iter().count(),
                "PetFacetSettings: power_q must carry exactly one row per facet"
            );
        }
        for (name, duration) in [
            ("overtime", settings.overtime_duration_ticks),
            ("safety_net", settings.safety_net_duration_ticks),
            ("wild_reading", settings.wild_reading_duration_ticks),
            ("life_bloom", settings.life_bloom_duration_ticks),
        ] {
            assert!(
                duration > 0,
                "PetFacetSettings: {name}_duration_ticks must be > 0 — a timed facet window with \
                 no expiry would last the whole fight"
            );
        }
        for (name, count) in [
            ("budget_plan_casts", settings.budget_plan_casts),
            ("magic_volley_bolts", settings.magic_volley_bolts),
            ("calibration_attacks", settings.calibration_attacks),
            (
                "lead_reading_activations",
                settings.lead_reading_activations,
            ),
            ("rising_gate_procs", settings.rising_gate_procs),
            ("souvenir_procs", settings.souvenir_procs),
        ] {
            assert!(count >= 1, "PetFacetSettings: {name} must be >= 1");
        }
        assert!(
            settings.budget_plan_cost_multiplier.is_finite()
                && (0.0..=1.0).contains(&settings.budget_plan_cost_multiplier),
            "PetFacetSettings: budget_plan_cost_multiplier must be in [0, 1] — Budget Plan is a \
             discount, never a surcharge"
        );
        assert!(
            settings.advance_notice_gauge_percent.is_finite()
                && (0.0..100.0).contains(&settings.advance_notice_gauge_percent),
            "PetFacetSettings: advance_notice_gauge_percent must be in [0, 100) — a phase that \
             opens at a full gauge would flip on its own first gain"
        );
        assert!(
            settings.safety_net_reduction_percent.is_finite()
                && (0.0..=100.0).contains(&settings.safety_net_reduction_percent),
            "PetFacetSettings: safety_net_reduction_percent must be in [0, 100]"
        );
        for (name, percent) in [
            ("second_spark", settings.second_spark_percent),
            ("open_tab_surcharge", settings.open_tab_surcharge_percent),
            (
                "open_tab_payload_share",
                settings.open_tab_payload_share_percent,
            ),
            (
                "overtime_attack_speed",
                settings.overtime_attack_speed_percent,
            ),
            ("magic_volley", settings.magic_volley_percent),
            ("retaliation", settings.retaliation_percent),
            ("calibration_crit", settings.calibration_crit_percent),
            ("lucky_star", settings.lucky_star_percent),
            (
                "lead_reading_resonance",
                settings.lead_reading_resonance_percent,
            ),
            ("wild_reading_effect", settings.wild_reading_effect_percent),
            (
                "rising_gate_multiplier_l1",
                settings.rising_gate_multiplier_l1,
            ),
            (
                "rising_gate_multiplier_l10",
                settings.rising_gate_multiplier_l10,
            ),
            ("prepared_slots", settings.prepared_slots_percent),
            ("first_spell", settings.first_spell_percent),
            ("souvenir", settings.souvenir_percent),
            ("dream_reader", settings.dream_reader_percent),
            ("packed_lunch_heal", settings.packed_lunch_heal_percent),
            ("life_bloom_l1", settings.life_bloom_percent_l1),
            ("life_bloom_l10", settings.life_bloom_percent_l10),
        ] {
            assert!(
                percent.is_finite() && percent >= 0.0,
                "PetFacetSettings: {name}_percent must be finite and >= 0"
            );
        }
    }

    fn validate_cores_settings(&self) {
        use std::collections::HashSet;

        let settings = &self.cores_settings;
        assert!(
            settings.unlock_chapter >= 0,
            "CoresSettings: unlock_chapter must be >= 0"
        );
        assert!(
            settings.unlock_essence_grant >= 0,
            "CoresSettings: unlock_essence_grant must be >= 0"
        );
        assert!(
            settings.max_core_level >= 1,
            "CoresSettings: max_core_level must be >= 1"
        );
        assert!(
            settings.max_slots_per_core >= 1,
            "CoresSettings: max_slots_per_core must be >= 1"
        );

        // The coupled trio, now keyed to the SLOT ladder rather than to the
        // level cap: at `max_slot_level` the ALLOWED bridge count
        // (`min(level, max_slot_level) - 1`) must stay strictly below the
        // physically possible count, otherwise "which bridges to keep" is no
        // longer a choice.
        //
        // Possible count = the number of slots, NOT `2 * slots`. The doubling
        // was the arithmetic of "a law sits in two bridges", which laws v0.2
        // repealed (`mechanics::cores::MAX_BRIDGES_PER_LAW == 1`): one law, one
        // partner, so five slotted laws per core can carry at most five bridges.
        // With the old doubling this assert passed while the invariant it exists
        // for was broken — 5 possible against 9 allowed.
        //
        // Before the acquisition pass the left-hand side read `max_core_level`
        // directly. Unbounded core levels made that read false — level 9999
        // would have "allowed" 9998 bridges — which is exactly why
        // `mechanics::cores::max_bridges` now clamps at the slot level too.
        let max_slot_level = settings.max_slot_level();
        let possible_bridges = settings.max_slots_per_core;
        let allowed_bridges = settings.max_core_level.min(max_slot_level) - 1;
        assert!(
            allowed_bridges < possible_bridges,
            "CoresSettings: the slot level {max_slot_level} allows {allowed_bridges} bridges but \
             only {possible_bridges} are possible at {} slots — the slot cap, the slot ladder and \
             the bridge limit move together",
            settings.max_slots_per_core,
        );

        assert!(
            settings.level_costs.iter().all(|row| row.level >= 1),
            "CoresSettings: level_costs may only price levels >= 1 (level 0 = no core yet)"
        );
        assert!(
            settings
                .level_costs
                .iter()
                .all(|row| row.level <= settings.max_core_level),
            "CoresSettings: level_costs must not price a level above max_core_level"
        );
        let mut priced_levels: Vec<i64> =
            settings.level_costs.iter().map(|row| row.level).collect();
        priced_levels.sort_unstable();
        priced_levels.dedup();
        assert_eq!(
            priced_levels.len(),
            settings.level_costs.len(),
            "CoresSettings: duplicate level in level_costs"
        );
        // The table no longer has to reach `max_core_level` — `level_cost_growth`
        // continues it — but it must be a CONTIGUOUS run, or `core_level_cost`
        // would hit a gap it refuses to price and the ladder would dead-end
        // below the cap.
        //
        // BAL-010 moved the start from 1 to 2: both cores are GRANTED at level 1
        // with the ch21 unlock, so level 1 is no longer purchasable and pricing
        // it would resurrect the removed 700 cost. Anything past 2 would leave a
        // level nobody can buy, which is why the start is pinned rather than
        // merely bounded.
        let first_priced = crate::cores::CORE_FIRST_PURCHASABLE_LEVEL;
        assert_eq!(
            priced_levels,
            (first_priced..=settings.max_tabled_core_level()).collect::<Vec<_>>(),
            "CoresSettings: level_costs must be a contiguous run of levels starting at {first_priced}"
        );
        // Every level that opens a slot must be priced explicitly: those are the
        // designed rungs, and letting the geometric extension invent their cost
        // would silently reprice the part of the ladder the design owns.
        assert!(
            settings.max_tabled_core_level() >= max_slot_level.min(settings.max_core_level),
            "CoresSettings: level_costs stops at level {} but slots keep opening until \
             {max_slot_level} — price every slot-opening level explicitly",
            settings.max_tabled_core_level(),
        );
        assert!(
            settings.level_cost_growth.get() > 1.0,
            "CoresSettings: level_cost_growth must be > 1 — a flat or shrinking cost above the \
             table turns the core into a free multiplier"
        );
        assert!(
            self.currencies
                .iter()
                .any(|currency| currency.id == settings.upgrade_currency_id),
            "CoresSettings: upgrade_currency_id {} is not a known currency",
            settings.upgrade_currency_id
        );
        assert!(
            (0.0..=1.0).contains(&settings.kill_drop.chance),
            "CoresSettings: kill_drop.chance must be in [0, 1]"
        );
        assert!(
            (0.0..=1.0).contains(&settings.law_drop_chance),
            "CoresSettings: law_drop_chance must be in [0, 1]"
        );
        assert!(
            !settings.multiplied_attribute_ids.is_empty(),
            "CoresSettings: multiplied_attribute_ids must not be empty"
        );
        for attribute_id in &settings.multiplied_attribute_ids {
            assert!(
                self.attributes.iter().any(|attr| attr.id == *attribute_id),
                "CoresSettings: multiplied_attribute_ids references unknown attribute \
                 {attribute_id}"
            );
        }

        let ladder_levels: Vec<i64> = settings
            .law_upgrade_ladder
            .iter()
            .map(|row| row.level)
            .collect();
        let mut sorted_ladder = ladder_levels.clone();
        sorted_ladder.sort_unstable();
        assert_eq!(
            ladder_levels, sorted_ladder,
            "CoresSettings: law_upgrade_ladder must be sorted by level"
        );
        assert_eq!(
            ladder_levels,
            (2..=(settings.max_law_level())).collect::<Vec<_>>(),
            "CoresSettings: law_upgrade_ladder must be a contiguous run starting at level 2"
        );

        // The charge trio became a PAIR (post-merge plan §8). The old identity
        // `capacity x per_unit == cap` made `BL-03 Short Span` inexpressible —
        // it moves capacity by -40% and the cap by -20% — so the per-unit field
        // is gone and amplification is a share of fullness. There is nothing
        // left to keep consistent here beyond the positivity the types already
        // guarantee.

        for law in &self.laws {
            assert!(
                law.resonance >= 0,
                "Law {}: resonance must not be negative",
                law.id
            );
            validate_power_q(
                &format!("Law {}", law.id),
                law.power_q_first_rank,
                law.power_q_max_rank,
            );
            // The deterministic unlock schedule. Bounded by the slot level, not
            // by `max_core_level`: with an unbounded cap the latter would let a
            // law hide behind level 4000, and "both cores at the last
            // slot-opening level = every law owned" is the rule the whole
            // schedule exists to guarantee.
            assert!(
                law.unlock_core_level >= 1 && law.unlock_core_level <= max_slot_level,
                "Law {}: unlock_core_level {} must be in 1..={max_slot_level} so every law is \
                 granted by the time the last slot opens",
                law.id,
                law.unlock_core_level,
            );
            assert!(
                law.condition != essences::cores::LawCondition::SkillWithTag
                    || law.condition_tag.is_some(),
                "Law {}: condition SkillWithTag needs a condition_tag",
                law.id
            );
            assert!(
                !law.effect.is_timed() || law.effect_duration_ticks > 0,
                "Law {}: effect {} is timed and needs a non-zero effect_duration_ticks, or it \
                 would never expire",
                law.id,
                law.effect
            );
            for modifier in &law.modifiers {
                assert!(
                    self.attributes
                        .iter()
                        .any(|attr| attr.id == modifier.attribute_id),
                    "Law {}: unknown attribute {}",
                    law.id,
                    modifier.attribute_id
                );
            }
        }
        let mut law_ids = HashSet::new();
        assert!(
            self.laws.iter().all(|law| law_ids.insert(law.id)),
            "Not unique law ids in config"
        );
    }

    /// Every rule the stone system relies on being true at load time.
    ///
    /// The three that carry real weight: the socket schedule must cover all 15
    /// sockets (a missing entry would silently make a socket unreachable
    /// forever), the coefficient matrix must cover every tier pair, including
    /// the reserved `Legendary` — a missing cell would read as `1.0` and hide a
    /// typo in a matrix whose whole point is being editable — and the upgrade
    /// ladder must cover `2..=max_stone_level` with no gap, because a missing
    /// rung reads as "already at the cap" and would quietly strand every stone
    /// one level below where the designer meant it to stop.
    fn validate_stones(&self) {
        use essences::stones::{StoneSocketKey, StoneTier};
        use std::collections::HashSet;
        use strum::IntoEnumIterator;

        let settings = &self.stones_settings;

        assert!(
            settings.global_trigger_cooldown_ticks > 0,
            "StonesSettings: global_trigger_cooldown_ticks must be > 0"
        );
        assert!(
            settings.max_stone_level >= 1,
            "StonesSettings: max_stone_level must be >= 1"
        );

        // BAL-032: the Beast Token AFK rate is FLAT wherever it is paid. The
        // card replaced a curve that grew from 0.018/min at ch11 to 420/min at
        // ch401 -- orders of magnitude of drift that broke the signed pet
        // catalog timing -- with one rate from the Pets gate upward. Bands below
        // the gate omit the currency entirely rather than paying zero.
        //
        // Checked here rather than in a test because the fixture carries no
        // Beast Token: this has to run against real content, which `deploy`
        // does.
        {
            let beast = self.game_settings.pet_gacha.currency_id;
            let paid: Vec<f64> = self
                .afk_rewards_levels
                .iter()
                .flat_map(|row| row.currency_rates.iter())
                .filter(|rate| rate.currency_id == beast)
                .map(|rate| rate.rate_per_minute.get())
                .collect();
            if let Some(first) = paid.first() {
                for rate in &paid {
                    assert!(
                        (rate - first).abs() < 1e-9,
                        "AfkRewardsByLevel: the Beast Token rate must be flat across \
                         every band that pays it (BAL-032), found {rate} alongside {first}"
                    );
                }
            }
        }

        // BAL-038: every authored D must be positive. A zero would make its
        // cap `ceil(0) = 0`, silently switching that faucet off for good rather
        // than merely capping it.
        let kf = &self.kill_faucet_settings;
        for (name, d) in [
            ("direct_cookies_d", kf.direct_cookies_d),
            ("law_copies_d", kf.law_copies_d),
            ("equipment_stones_d", kf.equipment_stones_d),
            ("artifact_stones_d", kf.artifact_stones_d),
        ] {
            assert!(d > 0.0, "KillFaucetSettings: {name} must be > 0, got {d}");
        }
        for (name, cap) in [
            (
                "skill_chapter_cap_with_pass",
                kf.skill_chapter_cap_with_pass,
            ),
            (
                "skill_chapter_cap_after_pass",
                kf.skill_chapter_cap_after_pass,
            ),
            ("boss_gems_daily_cap", kf.boss_gems_daily_cap),
        ] {
            assert!(cap > 0, "KillFaucetSettings: {name} must be > 0, got {cap}");
        }

        // BAL-012: the rarity step of the drop roll needs every tier priced
        // exactly once. A missing row would make that tier undrawable and a
        // duplicate would silently double its weight.
        let mut weighted_tiers = HashSet::new();
        for row in &settings.rarity_weights {
            assert!(
                row.weight >= 0.0,
                "StonesSettings: rarity weight for {:?} must be >= 0",
                row.tier
            );
            assert!(
                weighted_tiers.insert(row.tier),
                "StonesSettings: duplicate rarity weight for {:?}",
                row.tier
            );
        }
        for tier in StoneTier::iter() {
            assert!(
                weighted_tiers.contains(&tier),
                "StonesSettings: missing rarity weight for {tier:?}"
            );
        }
        assert!(
            settings
                .rarity_weights
                .iter()
                .map(|row| row.weight.max(0.0))
                .sum::<f64>()
                > 0.0,
            "StonesSettings: rarity weights must not all be zero"
        );

        // BAL-024/BAL-025: every guaranteed package references real catalog
        // entries exactly once — a dangling id would make the guarantee
        // silently unfulfillable.
        for grant in &settings.milestone_grants {
            assert!(
                grant.chapter >= 0,
                "StonesSettings: milestone grant chapter must be >= 0"
            );
            let mut seen = HashSet::new();
            for id in &grant.trigger_stones {
                assert!(
                    self.trigger_stones.iter().any(|stone| stone.id == *id),
                    "StonesSettings: milestone grant at chapter {} references unknown trigger stone {id}",
                    grant.chapter
                );
                assert!(
                    seen.insert(*id),
                    "StonesSettings: milestone grant at chapter {} lists {id} twice",
                    grant.chapter
                );
            }
            for id in &grant.effect_stones {
                assert!(
                    self.effect_stones.iter().any(|stone| stone.id == *id),
                    "StonesSettings: milestone grant at chapter {} references unknown effect stone {id}",
                    grant.chapter
                );
                assert!(
                    seen.insert(*id),
                    "StonesSettings: milestone grant at chapter {} lists {id} twice",
                    grant.chapter
                );
            }
        }

        // The ladder must price every level a stone can reach: a level with no
        // rung reads as "already at the cap", so a gap silently lowers the cap
        // instead of failing loudly.
        let mut priced = HashSet::new();
        for step in &settings.upgrade_ladder {
            assert!(
                (2..=settings.max_stone_level).contains(&step.level),
                "StonesSettings: upgrade_ladder prices level {}, outside 2..={}",
                step.level,
                settings.max_stone_level
            );
            assert!(
                step.copies >= 1,
                "StonesSettings: level {} must cost at least one copy",
                step.level
            );
            assert!(
                priced.insert(step.level),
                "StonesSettings: level {} is priced twice in upgrade_ladder",
                step.level
            );
        }
        for level in 2..=settings.max_stone_level {
            assert!(
                priced.contains(&level),
                "StonesSettings: upgrade_ladder has no cost for level {level}"
            );
        }
        // BAL-027: the gauge award is per template now; the tier ladder is gone.
        for stone in &self.trigger_stones {
            assert!(
                stone.gauge_gain.is_finite() && stone.gauge_gain >= 0.0,
                "TriggerStoneTemplate {}: gauge_gain must be finite and >= 0",
                stone.id
            );
            // BAL-030: the estimator scales an equipment package by how often
            // its trigger fires, so a zero rate would price a working package
            // at nothing.
            assert!(
                stone.power_proc_rate.is_finite() && stone.power_proc_rate > 0.0,
                "TriggerStoneTemplate {}: power_proc_rate must be finite and > 0",
                stone.id
            );
            if stone.condition == crate::stones::TriggerCondition::OnInterval {
                assert!(
                    stone.condition_value > 0,
                    "TriggerStoneTemplate {}: an interval condition needs a positive period",
                    stone.id
                );
            }
        }
        assert!(
            (0.0..=1.0).contains(&settings.kill_drop.chance),
            "StonesSettings: kill_drop.chance must be in [0, 1]"
        );
        assert!(
            (0.0..=1.0).contains(&settings.kill_drop.trigger_share),
            "StonesSettings: kill_drop.trigger_share must be in [0, 1]"
        );

        let scheduled: HashSet<(essences::items::ItemType, essences::stones::StoneSocketSlot)> =
            settings
                .socket_unlocks
                .iter()
                .map(|unlock| (unlock.item_type, unlock.socket))
                .collect();
        assert_eq!(
            scheduled.len(),
            settings.socket_unlocks.len(),
            "StonesSettings: duplicate socket in the unlock schedule"
        );
        for key in StoneSocketKey::all() {
            assert!(
                scheduled.contains(&(key.item_type, key.socket)),
                "StonesSettings: no unlock scheduled for {:?}/{:?}",
                key.item_type,
                key.socket
            );
        }
        for unlock in &settings.socket_unlocks {
            assert!(
                unlock.item_type.supports_world_side(),
                "StonesSettings: {:?} is not a two-sided slot and cannot carry sockets",
                unlock.item_type
            );
            assert!(
                unlock.unlock_chapter >= 0,
                "StonesSettings: unlock_chapter must be >= 0"
            );
        }

        let mut cells = HashSet::new();
        for cell in &settings.tier_coefficients {
            assert!(
                cell.multiplier.is_finite() && cell.multiplier > 0.0,
                "StonesSettings: tier coefficient must be finite and > 0"
            );
            assert!(
                cells.insert((cell.trigger_tier, cell.effect_tier)),
                "StonesSettings: duplicate tier coefficient cell"
            );
        }
        for trigger_tier in StoneTier::iter() {
            for effect_tier in StoneTier::iter() {
                assert!(
                    cells.contains(&(trigger_tier, effect_tier)),
                    "StonesSettings: no coefficient for {trigger_tier}x{effect_tier}"
                );
            }
        }

        let mut template_ids = HashSet::new();
        for stone in &self.trigger_stones {
            assert!(
                template_ids.insert(stone.id),
                "Not unique stone template ids in config"
            );
        }
        for stone in &self.effect_stones {
            assert!(
                template_ids.insert(stone.id),
                "Not unique stone template ids in config"
            );
            validate_power_q(
                &format!("EffectStoneTemplate {}", stone.id),
                stone.power_q_base_first_rank,
                stone.power_q_base_max_rank,
            );
        }

        // A stat pointing at a missing attribute would be silently dropped by
        // the aggregation, so the stone would quietly grant less than its UI
        // promises. Catch it at load instead.
        let mut seen_attrs = HashSet::new();
        for (stone_id, stats) in self
            .trigger_stones
            .iter()
            .map(|s| (s.id, &s.stats))
            .chain(self.effect_stones.iter().map(|s| (s.id, &s.stats)))
        {
            // The stone-detail UI promises "the stats it gives" for every
            // stone, and a socketed stone is meant to be worth something before
            // its trigger ever fires — so an empty block is a content bug, not
            // a valid design choice.
            assert!(
                !stats.is_empty(),
                "Stone {stone_id}: must grant at least one stat"
            );
            // Cleared per stone: two DIFFERENT stones may of course grant the
            // same attribute; only one stone listing it twice is the bug.
            seen_attrs.clear();
            for stat in stats {
                assert!(
                    self.attributes.iter().any(|a| a.id == stat.attribute_id),
                    "Stone {stone_id}: unknown stat attribute id {}",
                    stat.attribute_id
                );
                assert!(
                    seen_attrs.insert(stat.attribute_id),
                    "Stone {stone_id}: duplicate stat attribute id {} — merge the two entries",
                    stat.attribute_id
                );
            }
        }
        // Per-trigger invariants the panel cannot show: a windowed condition
        // with no window would never open, a window on an instant condition
        // would silently narrow it. Every condition is implementable today
        // (the mana pair got its mechanic when the pool shipped), so `active`
        // carries no code-side requirement any more — it is purely the
        // designer's switch for content that should wait.
        for stone in &self.trigger_stones {
            assert_eq!(
                stone.condition_window_ticks > 0,
                stone.condition.needs_window(),
                "Trigger stone {}: condition_window_ticks must be positive for a windowed \
                 condition and zero otherwise",
                stone.id
            );
            assert!(
                stone.condition_value >= 0,
                "Trigger stone {}: condition_value must not be negative",
                stone.id
            );
        }

        // Per-effect invariants, same reasoning: a timed action with no
        // duration would never expire, and a charge action with no charges is
        // a no-op the panel renders as a real effect.
        for stone in &self.effect_stones {
            assert_eq!(
                stone.duration_ticks > 0,
                stone.action.needs_duration(),
                "Effect stone {}: duration_ticks must be positive for a timed action and zero \
                 otherwise",
                stone.id
            );
            assert_eq!(
                stone.charges > 0,
                stone.action.needs_charges(),
                "Effect stone {}: charges must be positive for a charge-based action and zero \
                 otherwise",
                stone.id
            );
            for value in [
                stone.magnitude,
                stone.magnitude_per_level,
                stone.secondary_magnitude,
            ] {
                assert!(
                    value.is_finite() && value >= 0.0,
                    "Effect stone {}: magnitudes must be finite and >= 0",
                    stone.id
                );
            }
        }

        // BAL-027: every ACTIVE trigger must feed the gauge with its own
        // authored gain, or the stone fires for nothing.
        for stone in &self.trigger_stones {
            assert!(
                !stone.active || stone.gauge_gain > 0.0,
                "TriggerStoneTemplate {}: an active trigger needs a positive gauge_gain",
                stone.id
            );
        }
    }

    /// Collection Power is a real stat multiplier, so a mis-authored constant
    /// is a silent balance change rather than a crash. These checks catch the
    /// three ways that can happen: a weight table with a hole in it, a bonus
    /// authored on an attribute nothing composes, and a negative coefficient.
    fn validate_collection_power(&self) {
        use essences::stones::StoneTier;
        use strum::IntoEnumIterator;

        let settings = &self.collection_power;

        assert!(
            (0.0..=1.0).contains(&settings.first_ownership_share),
            "CollectionPowerSettings: first_ownership_share must be in 0..=1, got {}",
            settings.first_ownership_share
        );

        for (name, family) in [
            ("equipment_stones", &settings.equipment_stones),
            ("laws", &settings.laws),
            ("artifact_stones", &settings.artifact_stones),
            ("ability_stones", &settings.ability_stones),
            ("gacha_abilities", &settings.gacha_abilities),
            ("pets", &settings.pets),
        ] {
            assert!(
                family.k >= 0.0 && family.k.is_finite(),
                "CollectionPowerSettings: {name}.k must be finite and >= 0, got {}",
                family.k
            );
        }

        assert!(
            !settings.multiplied_attribute_ids.is_empty(),
            "CollectionPowerSettings: multiplied_attribute_ids must not be empty"
        );
        for attribute_id in &settings.multiplied_attribute_ids {
            let attribute = self
                .attributes
                .iter()
                .find(|attr| attr.id == *attribute_id)
                .unwrap_or_else(|| {
                    panic!(
                        "CollectionPowerSettings: multiplied attribute {attribute_id} is not in the catalog"
                    )
                });
            // The bonus is applied as `<code>.mod`. An attribute nothing
            // composes that way would take the budget and pay nothing.
            assert!(
                crate::artifacts::MOD_CAPABLE_ATTRIBUTE_CODES.contains(&attribute.code.as_str()),
                "CollectionPowerSettings: attribute '{}' has no `.mod` composition, so a collection bonus on it would be silently dropped",
                attribute.code
            );
        }

        // A missing tier or rarity row is worth catching here: it does not
        // crash, it just makes every template of that rarity pay nothing.
        for tier in StoneTier::iter() {
            assert!(
                settings
                    .stone_tier_weights
                    .iter()
                    .filter(|row| row.tier == tier)
                    .count()
                    == 1,
                "CollectionPowerSettings: stone_tier_weights needs exactly one row for {tier:?}"
            );
        }
        for rarity in &self.pet_rarities {
            assert!(
                settings
                    .pet_rarity_weights
                    .iter()
                    .filter(|row| row.rarity_id == rarity.id)
                    .count()
                    == 1,
                "CollectionPowerSettings: pet_rarity_weights needs exactly one row for pet rarity {}",
                rarity.id
            );
        }
        for row in settings
            .stone_tier_weights
            .iter()
            .map(|row| row.weight)
            .chain(settings.pet_rarity_weights.iter().map(|row| row.weight))
        {
            assert!(
                row > 0.0 && row.is_finite(),
                "CollectionPowerSettings: collection weights must be finite and > 0, got {row}"
            );
        }
    }

    /// Every rule the artifact system relies on being true at load time.
    ///
    /// The ones that carry real weight:
    ///
    /// * **all six sockets are scheduled** — a missing entry makes a socket
    ///   unreachable forever, and the whole point of the Law column shipping
    ///   early is that its sockets *exist*;
    /// * **the Aspect column opens strictly before the Law column** — a Law
    ///   stone has nothing to retune until the player owns cores, so the order
    ///   is design, not taste;
    /// * **both ladders price every level with no gap** — a missing rung reads
    ///   as "already at the cap" and would silently strand the item one level
    ///   below where the designer meant it to stop;
    /// * **every artifact level has an ownership row** — a missing row pays
    ///   nothing, which would look like a balance decision rather than a typo;
    /// * **a stone's declared socket matches its rule** — otherwise a Flip rule
    ///   could ship in a Visible socket, where nothing would ever run it.
    fn validate_artifacts(&self) {
        use essences::artifacts::ArtifactSocketSlot;
        use std::collections::HashSet;

        let settings = &self.artifacts_settings;

        assert!(
            settings.unlock_chapter >= 0,
            "ArtifactsSettings: unlock_chapter must be >= 0"
        );
        assert_eq!(
            settings.unlock_chapter, self.cores_settings.unlock_chapter,
            "ArtifactsSettings and CoresSettings must share the same unlock_chapter"
        );
        assert!(
            settings.max_artifact_level >= 1,
            "ArtifactsSettings: max_artifact_level must be >= 1"
        );
        assert!(
            settings.max_stone_level >= 1,
            "ArtifactsSettings: max_stone_level must be >= 1"
        );

        let mut artifact_ids = HashSet::new();
        for artifact in &self.artifacts {
            assert!(
                artifact_ids.insert(artifact.id),
                "Not unique artifact template ids in config"
            );

            validate_power_q(
                &format!("Artifact {}", artifact.id),
                artifact.power_q,
                artifact.power_q,
            );

            let mut bonus_attributes = HashSet::new();
            for bonus in &artifact.ownership_bonuses {
                let Some(attribute) = self
                    .attributes
                    .iter()
                    .find(|attr| attr.id == bonus.attribute_id)
                else {
                    panic!(
                        "Artifact {}: ownership bonus references unknown attribute {}",
                        artifact.id, bonus.attribute_id
                    );
                };
                // An ownership bonus is written as `<code>.mod`, and only the
                // codes the runtime composes are ever read back. Anything else
                // would be inert content that looks configured — refuse it here
                // rather than ship a bonus that does nothing.
                assert!(
                    crate::artifacts::MOD_CAPABLE_ATTRIBUTE_CODES
                        .contains(&attribute.code.as_str()),
                    "Artifact {}: ownership bonus on attribute '{}', whose `.mod` is composed by \
                     nothing — the bonus would be silently inert. Mod-capable codes: {:?}",
                    artifact.id,
                    attribute.code,
                    crate::artifacts::MOD_CAPABLE_ATTRIBUTE_CODES,
                );
                assert!(
                    bonus_attributes.insert(bonus.attribute_id),
                    "Artifact {}: attribute {} listed twice in ownership_bonuses — merge the rows, \
                     or the intent of the second one is invisible",
                    artifact.id,
                    bonus.attribute_id
                );
                for percent in [bonus.percent, bonus.percent_per_level] {
                    assert!(
                        percent.is_finite() && percent >= 0.0,
                        "Artifact {}: ownership bonus percentages must be finite and >= 0",
                        artifact.id
                    );
                }
            }
        }
        assert!(
            artifact_ids.contains(&settings.starter_artifact_id),
            "ArtifactsSettings: starter_artifact_id {} is not in the artifact catalog",
            settings.starter_artifact_id
        );
        assert!(
            self.artifacts
                .iter()
                .find(|artifact| artifact.id == settings.starter_artifact_id)
                .is_some_and(|artifact| artifact.world_law.is_none()),
            "ArtifactsSettings: the starter artifact must carry no World Law"
        );

        assert!(
            settings.halfway_bell_threshold_share.is_finite()
                && settings.halfway_bell_threshold_share > 0.0
                && settings.halfway_bell_threshold_share <= 1.0,
            "ArtifactsSettings: halfway_bell_threshold_share must be in (0, 1] — it is a share of \
             the configured flip threshold, not a threshold"
        );
        assert!(
            settings.thin_mirror_share.is_finite()
                && settings.thin_mirror_share > 0.0
                && settings.thin_mirror_share <= 1.0,
            "ArtifactsSettings: thin_mirror_share must be in (0, 1] — a hidden law runs at a \
             SHARE of Law Power, never above it"
        );

        let mut stone_ids = HashSet::new();
        let mut stone_rules = HashSet::new();
        for stone in &self.artifact_stones {
            assert!(
                stone_ids.insert(stone.id),
                "Not unique artifact stone template ids in config"
            );
            validate_power_q(
                &format!("Artifact stone {}", stone.id),
                stone.power_q_first_rank,
                stone.power_q_max_rank,
            );
            // One stone per rule: two entries carrying one rule would be the same
            // stone twice, and the socket that holds one of them would offer a
            // choice that is not a choice.
            assert!(
                stone_rules.insert(stone.rule),
                "Artifact stone {}: rule {:?} is already carried by another stone",
                stone.id,
                stone.rule
            );
            assert_eq!(
                stone.socket,
                stone.rule.socket(),
                "Artifact stone {}: rule {:?} belongs in socket {:?}, not {:?}",
                stone.id,
                stone.rule,
                stone.rule.socket(),
                stone.socket
            );
            assert!(
                stone.magnitude.is_finite()
                    && stone.magnitude_per_level.is_finite()
                    && stone.secondary_magnitude.is_finite(),
                "Artifact stone {}: magnitudes must be finite",
                stone.id
            );
            assert!(
                stone.rule_param >= 0,
                "Artifact stone {}: rule_param must be >= 0",
                stone.id
            );
            // The load-time half of the "switched off" guard: a rule whose
            // mechanic is not on this branch cannot be turned on by a config
            // edit alone, and the reason travels with the refusal.
            if let Some(dependency) = stone.rule.unavailable_dependency() {
                assert!(
                    !stone.active,
                    "Artifact stone {}: rule {:?} needs {dependency} — it must ship with \
                     active: false",
                    stone.id, stone.rule
                );
            }
            let mut tiers = HashSet::new();
            for entry in &stone.tier_magnitudes {
                assert!(
                    tiers.insert(entry.tier),
                    "Artifact stone {}: tier {:?} listed twice in tier_magnitudes",
                    stone.id,
                    entry.tier
                );
                assert!(
                    entry.magnitude.is_finite() && entry.magnitude >= 0.0,
                    "Artifact stone {}: tier magnitudes must be finite and >= 0",
                    stone.id
                );
            }
            assert!(
                stone.tier_magnitudes.is_empty()
                    || stone.rule == crate::artifacts::ArtifactStoneRule::SmallGears,
                "Artifact stone {}: only «Мелкие шестерни» reads tier_magnitudes",
                stone.id
            );
        }
        // The two catalogs are addressed by template id from the same client
        // calls, so a shared id would make one of them unreachable.
        for stone in &self.artifact_stones {
            assert!(
                !artifact_ids.contains(&stone.id),
                "Artifact stone {} shares its id with an artifact",
                stone.id
            );
        }
        // Both columns ship now that the cores vertical landed. What still has
        // to hold is that every socket offers a real choice: the left column has
        // five stones per socket, the right has five, five and four — `BL-04
        // Priority Gate` was cut (post-merge plan §8), so the Bridge Law socket
        // is the one place a socket offers four.
        for socket in ArtifactSocketSlot::all() {
            let offered = self
                .artifact_stones
                .iter()
                .filter(|stone| stone.socket == socket)
                .count();
            assert!(
                offered >= 4,
                "ArtifactsSettings: socket {socket} offers only {offered} stones — a socket is a \
                 choice between readings, and fewer than four is not one"
            );
        }

        let scheduled: HashSet<ArtifactSocketSlot> = settings
            .socket_unlocks
            .iter()
            .map(|unlock| unlock.socket)
            .collect();
        assert_eq!(
            scheduled.len(),
            settings.socket_unlocks.len(),
            "ArtifactsSettings: duplicate socket in the unlock schedule"
        );
        for socket in ArtifactSocketSlot::all() {
            assert!(
                scheduled.contains(&socket),
                "ArtifactsSettings: no unlock scheduled for {socket}"
            );
        }
        for unlock in &settings.socket_unlocks {
            assert!(
                unlock.unlock_chapter >= 0,
                "ArtifactsSettings: unlock_chapter must be >= 0"
            );
        }
        // Fixed order: the whole Aspect column, then the whole Law column.
        let mut previous = -1_i64;
        for socket in ArtifactSocketSlot::all() {
            let chapter = settings
                .socket_unlocks
                .iter()
                .find(|unlock| unlock.socket == socket)
                .map(|unlock| unlock.unlock_chapter)
                .expect("every socket is scheduled");
            assert!(
                chapter >= previous,
                "ArtifactsSettings: {socket} opens before an earlier socket — the order is \
                 fixed: the Aspect column first, then the Law column"
            );
            previous = chapter;
        }

        Self::validate_artifact_ladder(
            "upgrade_ladder",
            &settings.upgrade_ladder,
            settings.max_artifact_level,
        );
        Self::validate_artifact_ladder(
            "stone_upgrade_ladder",
            &settings.stone_upgrade_ladder,
            settings.max_stone_level,
        );

        for chance in [
            settings.stone_drop.chapter_boss_chance,
            settings.stone_drop.dungeon_chance,
            settings.stone_drop.mob_kill_chance,
        ] {
            assert!(
                (0.0..=1.0).contains(&chance),
                "ArtifactsSettings: stone drop chances must be in [0, 1]"
            );
        }
    }

    /// Shared shape check for both artifact ladders: rungs `2..=max`, no gaps,
    /// no duplicates, at least one copy each.
    fn validate_artifact_ladder(
        name: &str,
        ladder: &[crate::artifacts::ArtifactUpgradeStep],
        max_level: i64,
    ) {
        use std::collections::HashSet;

        let mut priced = HashSet::new();
        for step in ladder {
            assert!(
                (2..=max_level).contains(&step.level),
                "ArtifactsSettings: {name} prices level {}, outside 2..={max_level}",
                step.level
            );
            assert!(
                step.copies >= 1,
                "ArtifactsSettings: {name} level {} must cost at least one copy",
                step.level
            );
            assert!(
                priced.insert(step.level),
                "ArtifactsSettings: {name} prices level {} twice",
                step.level
            );
        }
        for level in 2..=max_level {
            assert!(
                priced.contains(&level),
                "ArtifactsSettings: {name} has no cost for level {level}"
            );
        }
    }

    fn validate_inventory_levels(&self) {
        use std::collections::HashSet;

        assert!(
            !self.inventory_levels.is_empty(),
            "InventoryLevels must not be empty"
        );
        assert!(
            self.inventory_levels[0].from_chapter_level == 0,
            "InventoryLevels must start at chapter 0"
        );

        for pair in self.inventory_levels.windows(2) {
            let (previous, next) = (&pair[0], &pair[1]);
            assert!(
                next.from_chapter_level > previous.from_chapter_level,
                "InventoryLevels chapters must be strictly increasing"
            );
            assert!(
                next.slots.starts_with(&previous.slots),
                "InventoryLevels slots must be cumulative and preserve their order"
            );
        }

        for level in &self.inventory_levels {
            assert!(
                !level.slots.is_empty(),
                "InventoryLevel chapter {} must contain slots",
                level.from_chapter_level
            );

            let mut unique_slots = HashSet::new();
            for slot in &level.slots {
                assert!(
                    unique_slots.insert(*slot),
                    "InventoryLevel chapter {} contains duplicate slot {} {:?}",
                    level.from_chapter_level,
                    slot.item_type,
                    slot.world_side
                );

                match (slot.item_type.supports_world_side(), slot.world_side) {
                    (true, None) => panic!(
                        "InventoryLevel chapter {} flip slot {} must define world_side",
                        level.from_chapter_level, slot.item_type
                    ),
                    (false, Some(side)) => panic!(
                        "InventoryLevel chapter {} fixed slot {} must not define world_side ({side})",
                        level.from_chapter_level, slot.item_type
                    ),
                    _ => {}
                }

                assert!(
                    self.items
                        .iter()
                        .any(|item| item.equipment_slot_key() == slot.equipment_slot_key()),
                    "InventoryLevel chapter {} slot {} {:?} has no item templates",
                    level.from_chapter_level,
                    slot.item_type,
                    slot.world_side
                );
            }
        }

        for level in self
            .inventory_levels
            .iter()
            .filter(|level| level.from_chapter_level < self.flip_settings.unlock_chapter)
        {
            assert!(
                level
                    .slots
                    .iter()
                    .all(|slot| slot.world_side != Some(essences::flip::WorldSide::Real)),
                "InventoryLevels must not unlock Real slots before FlipSettings.unlock_chapter"
            );
        }

        let unlock_level = self
            .inventory_levels
            .iter()
            .find(|level| level.from_chapter_level == self.flip_settings.unlock_chapter)
            .unwrap_or_else(|| {
                panic!(
                    "InventoryLevels must contain a level at FlipSettings.unlock_chapter ({})",
                    self.flip_settings.unlock_chapter
                )
            });
        assert!(
            unlock_level
                .slots
                .iter()
                .any(|slot| { slot.world_side == Some(essences::flip::WorldSide::Real) }),
            "InventoryLevel at flip unlock must contain Real slots"
        );
    }

    fn validate_item_world_sides(&self) {
        for item in &self.items {
            match (item.item_type.supports_world_side(), item.world_side) {
                (true, None) => panic!(
                    "ItemTemplate {} ({}) must define world_side",
                    item.id, item.item_type
                ),
                (false, Some(side)) => panic!(
                    "ItemTemplate {} ({}) must not define world_side ({side})",
                    item.id, item.item_type
                ),
                _ => {}
            }
        }
    }

    pub fn class_level(&self, class_id: class::ClassId, level: u64) -> Option<&class::ClassLevels> {
        self.class_levels
            .iter()
            .find(|row| row.class_id == class_id && row.level == level)
    }

    fn validate_progress_pass_config(progress_pass: &essences::progress_pass::ProgressPassConfig) {
        use std::collections::HashSet;

        let mut tier_values: HashSet<u32> = HashSet::new();
        for tier in &progress_pass.tiers {
            if tier.quest_template_ids.is_empty() {
                panic!(
                    "ProgressPassConfig: tier {} has no quest_template_ids",
                    tier.tier
                );
            }
            if !tier_values.insert(tier.tier) {
                panic!("ProgressPassConfig: duplicate tier value {}", tier.tier);
            }
        }
    }

    fn validate_progress_pass_references(&self) {
        let pp = &self.progress_pass;

        if pp.tiers.is_empty() {
            return;
        }

        if !self
            .offers_templates
            .iter()
            .any(|o| o.id == pp.premium_offer_template_id)
        {
            panic!(
                "ProgressPassConfig: premium_offer_template_id {} does not match any offer template",
                pp.premium_offer_template_id
            );
        }

        for tier in &pp.tiers {
            for quest_id in &tier.quest_template_ids {
                let Some(quest) = self.quests.iter().find(|q| q.id == *quest_id) else {
                    panic!(
                        "ProgressPassConfig: tier {} references unknown quest template {quest_id}",
                        tier.tier
                    );
                };
                if quest.quest_group_type != QuestGroupType::ProgressPass {
                    panic!(
                        "ProgressPassConfig: tier {} references quest {quest_id} whose group is {:?}, expected ProgressPass",
                        tier.tier, quest.quest_group_type
                    );
                }
            }

            if !self
                .bundles
                .iter()
                .any(|b| b.id == tier.free_reward_bundle_id)
            {
                panic!(
                    "ProgressPassConfig: tier {} free_reward_bundle_id {} does not match any bundle",
                    tier.tier, tier.free_reward_bundle_id
                );
            }
            if !self
                .bundles
                .iter()
                .any(|b| b.id == tier.paid_reward_bundle_id)
            {
                panic!(
                    "ProgressPassConfig: tier {} paid_reward_bundle_id {} does not match any bundle",
                    tier.tier, tier.paid_reward_bundle_id
                );
            }
        }
    }

    fn validate_loop_task_chain(quests: &[QuestTemplate]) {
        use std::collections::{HashMap, HashSet};

        let loop_quests: Vec<&QuestTemplate> = quests
            .iter()
            .filter(|q| q.quest_group_type == QuestGroupType::LoopTask)
            .collect();

        if loop_quests.is_empty() {
            return;
        }

        let all_quest_ids: HashSet<_> = quests.iter().map(|q| q.id).collect();
        let loop_quest_ids: HashSet<_> = loop_quests.iter().map(|q| q.id).collect();

        // 1. No duplicate codes among LoopTask quests
        let mut code_to_quest: HashMap<&str, &QuestTemplate> = HashMap::new();
        for q in &loop_quests {
            if let Some(code) = &q.code
                && let Some(existing) = code_to_quest.insert(code.as_str(), q)
            {
                panic!(
                    "LoopTask: duplicate code '{}' on quests {} and {}",
                    code, existing.id, q.id
                );
            }
        }

        // 2. Every next_quest_ids reference must point to an existing quest
        for q in &loop_quests {
            for next_id in &q.next_quest_ids {
                if !all_quest_ids.contains(next_id) {
                    panic!(
                        "LoopTask: quest {} ('{}') has next_quest_id {} that does not exist",
                        q.id,
                        q.code.as_deref().unwrap_or("<no code>"),
                        next_id
                    );
                }
            }
        }

        // 3. Discover numbered sequences (loop_task.{type}.{N}) and verify each is
        //    a gapless 1..=max chain where N chains to N+1 via next_quest_ids.
        let mut sequences: HashMap<String, Vec<(u32, &QuestTemplate)>> = HashMap::new();
        for (code, quest) in &code_to_quest {
            let parts: Vec<&str> = code.split('.').collect();
            // codes look like "loop_task.{type}.{number_or_name}"
            if parts.len() == 3
                && parts[0] == "loop_task"
                && let Ok(n) = parts[2].parse::<u32>()
            {
                sequences
                    .entry(parts[1].to_string())
                    .or_default()
                    .push((n, quest));
            }
        }

        for (seq_type, mut entries) in sequences {
            entries.sort_by_key(|(n, _)| *n);

            // Must start from 1
            if entries[0].0 != 1 {
                panic!(
                    "LoopTask: sequence 'loop_task.{}' starts at {} instead of 1",
                    seq_type, entries[0].0
                );
            }

            // No gaps
            for (i, (n, _)) in entries.iter().enumerate() {
                let expected = (i as u32) + 1;
                if *n != expected {
                    panic!(
                        "LoopTask: sequence 'loop_task.{}' has gap — expected {} but found {}",
                        seq_type, expected, n
                    );
                }
            }

            // Each N must chain to N+1 via next_quest_ids (except last).
            if seq_type != "loop" {
                for window in entries.windows(2) {
                    let (n, quest) = window[0];
                    let (_, next_quest) = window[1];
                    if !quest.next_quest_ids.contains(&next_quest.id) {
                        panic!(
                            "LoopTask: 'loop_task.{}.{}' (quest {}) does not chain to 'loop_task.{}.{}' (quest {}) via next_quest_ids",
                            seq_type,
                            n,
                            quest.id,
                            seq_type,
                            n + 1,
                            next_quest.id
                        );
                    }
                }
            }
        }

        // 4. Every LoopTask quest must be reachable: either has a code (discoverable by scripts)
        //    or is in the next_quest_ids graph from any quest in the config
        let mut reachable: HashSet<essences::quest::QuestId> = HashSet::new();

        // Reachable by code
        for q in code_to_quest.values() {
            reachable.insert(q.id);
        }

        // Reachable by next_quest_ids graph (BFS from all quests that reference LoopTask quests)
        let mut stack: Vec<essences::quest::QuestId> = Vec::new();
        for q in quests {
            for next_id in &q.next_quest_ids {
                if loop_quest_ids.contains(next_id) {
                    stack.push(*next_id);
                }
            }
        }
        while let Some(id) = stack.pop() {
            if !reachable.insert(id) {
                continue;
            }
            if let Some(q) = loop_quests.iter().find(|q| q.id == id) {
                for next_id in &q.next_quest_ids {
                    if loop_quest_ids.contains(next_id) {
                        stack.push(*next_id);
                    }
                }
            }
        }

        for q in &loop_quests {
            if !reachable.contains(&q.id) {
                panic!(
                    "LoopTask: quest {} ('{}') is unreachable — no code and not in next_quest_ids chain from a starting quest",
                    q.id,
                    q.code.as_deref().unwrap_or("<no code>")
                );
            }
        }
    }

    fn validate_afk_rewards(
        afk_levels: &[AfkRewardsByLevel],
        afk_settings: &AfkRewardsSettings,
        currencies: &[Currency],
        abilities: &[AbilityTemplate],
        items: &[ItemTemplate],
        bundles: &[BundleRaw],
    ) {
        use std::collections::HashSet;

        let currency_ids: HashSet<_> = currencies.iter().map(|c| c.id).collect();
        let ability_ids: HashSet<_> = abilities.iter().map(|a| a.id).collect();
        let item_ids: HashSet<_> = items.iter().map(|i| i.id).collect();
        let bundle_ids: HashSet<_> = bundles.iter().map(|b| b.id).collect();

        // bonus_calculation_rate_sec > 0 is enforced by NonZeroU64 type

        if !bundle_ids.contains(&afk_settings.bundle_id) {
            panic!(
                "AfkRewardsSettings: bundle_id {} not found in bundles",
                afk_settings.bundle_id
            );
        }

        let chapter_levels: Vec<_> = afk_levels.iter().map(|r| r.chapter_level).collect();
        let unique_levels: HashSet<_> = chapter_levels.iter().collect();
        if chapter_levels.len() != unique_levels.len() {
            panic!("AfkRewardsByLevel: Two or more afk reward levels have equal chapter_level");
        }

        for level_rewards in afk_levels {
            for rate in &level_rewards.currency_rates {
                if !currency_ids.contains(&rate.currency_id) {
                    panic!(
                        "AfkRewardsByLevel chapter_level={}: currency_id {} not found in currencies",
                        level_rewards.chapter_level, rate.currency_id
                    );
                }
                // rate_per_minute > 0 is enforced by PositiveF64 type
            }

            // bonus_weights non-empty is enforced by NonEmptyVec type
            // bonus_weight.weight > 0 is enforced by PositiveF64 type
            // bonus_weight.count > 0 is enforced by PositiveI64 type

            for bonus_weight in &level_rewards.bonus_weights {
                match &bonus_weight.bonus_type {
                    AfkRewardBonusType::Currency(currency_id) => {
                        if !currency_ids.contains(currency_id) {
                            panic!(
                                "AfkRewardsByLevel chapter_level={}: bonus Currency id {} not found",
                                level_rewards.chapter_level, currency_id
                            );
                        }
                    }
                    AfkRewardBonusType::Ability(ability_id) => {
                        if !ability_ids.contains(ability_id) {
                            panic!(
                                "AfkRewardsByLevel chapter_level={}: bonus Ability id {} not found",
                                level_rewards.chapter_level, ability_id
                            );
                        }
                    }
                    AfkRewardBonusType::Item(item_id) => {
                        if !item_ids.contains(item_id) {
                            panic!(
                                "AfkRewardsByLevel chapter_level={}: bonus Item id {} not found",
                                level_rewards.chapter_level, item_id
                            );
                        }
                    }
                }
            }
        }
    }

    fn validate_ability_gacha_settings(&self) {
        use std::collections::HashSet;

        let gacha = &self.game_settings.ability_gacha;
        let currency_ids: HashSet<_> = self.currencies.iter().map(|currency| currency.id).collect();
        let rarity_ids: HashSet<_> = self
            .ability_rarities
            .iter()
            .map(|rarity| rarity.id)
            .collect();
        let class_rarity_ids: HashSet<_> = self
            .classes
            .iter()
            .map(|class| class.ability_rarity_id)
            .collect();

        // small_roll_cost > 0, big_roll_cost > 0, slot_max_level > 0 enforced by PositiveI64
        // wishlist_weight_multiplier >= 1.0 enforced by WeightMultiplier type
        // wishlist_slots > 0 still needs runtime check (u8, not wrapped)
        if gacha.wishlist_slots == 0 {
            panic!("AbilityGachaSettings: wishlist_slots must be > 0");
        }
        if gacha.slot_level_costs.len() != gacha.slot_max_level.get() as usize {
            panic!(
                "AbilityGachaSettings: slot_level_costs length ({}) must match slot_max_level ({})",
                gacha.slot_level_costs.len(),
                gacha.slot_max_level.get()
            );
        }
        if gacha.slot_level_bonus_levels.len() != gacha.slot_max_level.get() as usize + 1 {
            panic!(
                "AbilityGachaSettings: slot_level_bonus_levels length ({}) must be slot_max_level + 1 ({})",
                gacha.slot_level_bonus_levels.len(),
                gacha.slot_max_level.get() + 1
            );
        }
        // slot_level_costs values > 0 enforced by PositiveI64 type
        for bonus in &gacha.slot_level_bonus_levels {
            if *bonus < 0 {
                panic!("AbilityGachaSettings: slot_level_bonus_levels values must be >= 0");
            }
        }
        if !currency_ids.contains(&gacha.slot_upgrade_currency_id) {
            panic!(
                "AbilityGachaSettings: slot_upgrade_currency_id {} not found in currencies",
                gacha.slot_upgrade_currency_id
            );
        }

        // ability_cases_settings non-empty is enforced by NonEmptyVec type

        let mut settings_by_level = self.ability_cases_settings.to_vec();
        settings_by_level.sort_by_key(|level_settings| level_settings.level);

        // Validate boundary levels: at most one, must be the last level.
        let boundary_count = settings_by_level
            .iter()
            .filter(|s| s.is_boundary_level)
            .count();
        if boundary_count > 1 {
            panic!("AbilityCasesSettings: at most one boundary level is allowed");
        }
        if boundary_count == 1 && !settings_by_level.last().unwrap().is_boundary_level {
            panic!("AbilityCasesSettings: the boundary level must be the last level");
        }

        let mut previous_level = 0;
        let mut previous_opens = -1;
        for (idx, level_settings) in settings_by_level.iter().enumerate() {
            if level_settings.level <= previous_level {
                panic!("AbilityCasesSettings: levels must be unique and strictly increasing");
            }
            if level_settings.opens_to_upgrade < 0 {
                panic!(
                    "AbilityCasesSettings level {}: opens_to_upgrade must be >= 0",
                    level_settings.level
                );
            }
            if level_settings.opens_to_upgrade < previous_opens {
                panic!(
                    "AbilityCasesSettings level {}: opens_to_upgrade must be non-decreasing",
                    level_settings.level
                );
            }
            previous_level = level_settings.level;
            previous_opens = level_settings.opens_to_upgrade;

            // Boundary levels only need level + opens_to_upgrade; skip all other validations.
            if level_settings.is_boundary_level {
                continue;
            }

            let mut previous_checkpoint_opens = -1;
            for checkpoint in &level_settings.checkpoints {
                if checkpoint.required_opens <= 0 {
                    panic!(
                        "AbilityCasesSettings level {}: checkpoint required_opens must be > 0",
                        level_settings.level
                    );
                }
                if checkpoint.required_opens <= previous_checkpoint_opens {
                    panic!(
                        "AbilityCasesSettings level {}: checkpoint required_opens must be strictly increasing",
                        level_settings.level
                    );
                }
                previous_checkpoint_opens = checkpoint.required_opens;

                // Checkpoint required_opens is relative to the current level's
                // opens_to_upgrade. It must not exceed the range of this level
                // (i.e. the gap to the next level's opens_to_upgrade).
                if let Some(next) = settings_by_level.get(idx + 1) {
                    let level_range = next.opens_to_upgrade - level_settings.opens_to_upgrade;
                    if checkpoint.required_opens > level_range {
                        panic!(
                            "AbilityCasesSettings level {}: checkpoint required_opens ({}) exceeds level range ({})",
                            level_settings.level, checkpoint.required_opens, level_range
                        );
                    }
                }

                for currency_reward in &checkpoint.currency_rewards {
                    if currency_reward.amount <= 0 {
                        panic!(
                            "AbilityCasesSettings level {}: checkpoint currency reward must be > 0",
                            level_settings.level
                        );
                    }
                    if !currency_ids.contains(&currency_reward.currency_id) {
                        panic!(
                            "AbilityCasesSettings level {}: checkpoint currency {} not found",
                            level_settings.level, currency_reward.currency_id
                        );
                    }
                }

                for ability_reward in &checkpoint.ability_rewards {
                    if ability_reward.amount < 0 {
                        panic!(
                            "AbilityCasesSettings level {}: checkpoint ability reward amount must be >= 0",
                            level_settings.level
                        );
                    }
                    if ability_reward.amount > 0
                        && !rarity_ids.contains(&ability_reward.min_rarity_id)
                    {
                        panic!(
                            "AbilityCasesSettings level {}: checkpoint ability reward min_rarity_id {} not found",
                            level_settings.level, ability_reward.min_rarity_id
                        );
                    }
                }
            }

            for rarity_id in &level_settings.allowed_wishlist_rarity_ids {
                if !rarity_ids.contains(rarity_id) {
                    panic!(
                        "AbilityCasesSettings level {}: allowed wishlist rarity {} not found",
                        level_settings.level, rarity_id
                    );
                }
                if class_rarity_ids.contains(rarity_id) {
                    panic!(
                        "AbilityCasesSettings level {}: class rarity {} cannot be in wishlist",
                        level_settings.level, rarity_id
                    );
                }
            }

            for evolve_rule in &level_settings.evolve_rules {
                if evolve_rule.small_roll_tries < 0 {
                    panic!(
                        "AbilityCasesSettings level {}: evolve small_roll_tries must be >= 0",
                        level_settings.level
                    );
                }
                if evolve_rule.big_roll_tries < 0 {
                    panic!(
                        "AbilityCasesSettings level {}: evolve big_roll_tries must be >= 0",
                        level_settings.level
                    );
                }
                if evolve_rule.small_roll_tries == 0 && evolve_rule.big_roll_tries == 0 {
                    panic!(
                        "AbilityCasesSettings level {}: evolve rule must have at least one non-zero tries",
                        level_settings.level
                    );
                }
                if !rarity_ids.contains(&evolve_rule.from_rarity_id) {
                    panic!(
                        "AbilityCasesSettings level {}: evolve from rarity {} not found",
                        level_settings.level, evolve_rule.from_rarity_id
                    );
                }
                // rarity_weight.weight > 0 enforced by PositiveF64 type
                let mut sum_weight = 0.0;
                for rarity_weight in &evolve_rule.to_rarity_weights {
                    if !rarity_ids.contains(&rarity_weight.rarity_id) {
                        panic!(
                            "AbilityCasesSettings level {}: evolve to rarity {} not found",
                            level_settings.level, rarity_weight.rarity_id
                        );
                    }
                    sum_weight += rarity_weight.weight.get();
                }
                if sum_weight > 1.0 + f64::EPSILON {
                    panic!(
                        "AbilityCasesSettings level {}: evolve to_rarity_weights sum must be <= 1.0, got {}",
                        level_settings.level, sum_weight
                    );
                }
            }

            for currency_reward in &level_settings.big_roll_currency_rewards {
                if currency_reward.amount <= 0 {
                    panic!(
                        "AbilityCasesSettings level {}: big-roll currency reward amount must be > 0",
                        level_settings.level
                    );
                }
                if !currency_ids.contains(&currency_reward.currency_id) {
                    panic!(
                        "AbilityCasesSettings level {}: big-roll currency {} not found",
                        level_settings.level, currency_reward.currency_id
                    );
                }
            }

            let big_roll_shards = &level_settings.big_roll_shards;
            let shards_total: u64 = big_roll_shards.iter().map(|s| s.count as u64).sum();
            let expected_total =
                gacha.big_roll_cost.get() as u64 + gacha.big_roll_bonus_drops as u64;
            if shards_total != expected_total {
                panic!(
                    "AbilityCasesSettings level {}: big_roll_shards total ({}) must equal big_roll_cost + bonus_drops ({})",
                    level_settings.level, shards_total, expected_total
                );
            }
            for shard in big_roll_shards {
                if shard.count == 0 {
                    panic!(
                        "AbilityCasesSettings level {}: big_roll_shards count must be > 0",
                        level_settings.level
                    );
                }
                if !rarity_ids.contains(&shard.min_rarity_id) {
                    panic!(
                        "AbilityCasesSettings level {}: big_roll_shards rarity {} not found",
                        level_settings.level, shard.min_rarity_id
                    );
                }
            }
        }

        if settings_by_level[0].level != 1 || settings_by_level[0].opens_to_upgrade != 0 {
            panic!("AbilityCasesSettings: level 1 with opens_to_upgrade = 0 is required");
        }
    }

    fn validate_pet_config(&self) {
        use std::collections::HashSet;

        let pet_template_ids: HashSet<_> = self.pet_templates.iter().map(|t| t.id).collect();
        if pet_template_ids.len() != self.pet_templates.len() {
            panic!("PetConfig: duplicate pet template ids");
        }

        let pet_rarity_ids: HashSet<_> = self.pet_rarities.iter().map(|r| r.id).collect();
        if pet_rarity_ids.len() != self.pet_rarities.len() {
            panic!("PetConfig: duplicate pet rarity ids");
        }

        let attribute_ids: HashSet<_> = self.attributes.iter().map(|a| a.id).collect();

        for template in &self.pet_templates {
            if !pet_rarity_ids.contains(&template.rarity_id) {
                panic!(
                    "PetConfig: pet template {} has rarity_id {} not found in pet_rarities",
                    template.id, template.rarity_id
                );
            }
            for stat in &template.stats {
                if !attribute_ids.contains(&stat.attribute_id) {
                    panic!(
                        "PetConfig: pet template {} has stat attribute_id {} not found in attributes",
                        template.id, stat.attribute_id
                    );
                }
            }
        }

        for pet_level in &self.pet_levels {
            if !pet_rarity_ids.contains(&pet_level.rarity_id) {
                panic!(
                    "PetConfig: pet level {} has rarity_id {} not found in pet_rarities",
                    pet_level.level, pet_level.rarity_id
                );
            }
            if pet_level.required_shards < 0 {
                panic!(
                    "PetConfig: pet level {} (rarity {}) required_shards must be >= 0",
                    pet_level.level, pet_level.rarity_id
                );
            }
        }
    }

    /// Mirror of `validate_ability_gacha_settings` for the pet gacha:
    /// same level/checkpoint/big-roll invariants on `pet_cases_settings`,
    /// minus the ability-only parts (slot upgrades, evolve rules, class rarities).
    fn validate_pet_gacha_settings(&self) {
        use std::collections::HashSet;

        let gacha = &self.game_settings.pet_gacha;
        let currency_ids: HashSet<_> = self.currencies.iter().map(|currency| currency.id).collect();
        let rarity_ids: HashSet<_> = self.pet_rarities.iter().map(|rarity| rarity.id).collect();

        // roll_price_in_diamonds > 0, small_roll_cost > 0, big_roll_cost > 0 enforced by PositiveI64
        // wishlist_weight_multiplier >= 1.0 enforced by WeightMultiplier type
        // wishlist_slots > 0 still needs runtime check (u8, not wrapped)
        if gacha.wishlist_slots == 0 {
            panic!("PetGachaSettings: wishlist_slots must be > 0");
        }
        if !currency_ids.contains(&gacha.currency_id) {
            panic!(
                "PetGachaSettings: currency_id {} not found in currencies",
                gacha.currency_id
            );
        }

        if self.pet_cases_settings.is_empty() {
            panic!("PetCasesSettings: must not be empty");
        }

        let mut settings_by_level = self.pet_cases_settings.clone();
        settings_by_level.sort_by_key(|level_settings| level_settings.level);

        // Validate boundary levels: at most one, must be the last level.
        let boundary_count = settings_by_level
            .iter()
            .filter(|s| s.is_boundary_level)
            .count();
        if boundary_count > 1 {
            panic!("PetCasesSettings: at most one boundary level is allowed");
        }
        if boundary_count == 1 && !settings_by_level.last().unwrap().is_boundary_level {
            panic!("PetCasesSettings: the boundary level must be the last level");
        }

        let mut previous_level = 0;
        let mut previous_opens = -1;
        for (idx, level_settings) in settings_by_level.iter().enumerate() {
            if level_settings.level <= previous_level {
                panic!("PetCasesSettings: levels must be unique and strictly increasing");
            }
            if level_settings.opens_to_upgrade < 0 {
                panic!(
                    "PetCasesSettings level {}: opens_to_upgrade must be >= 0",
                    level_settings.level
                );
            }
            if level_settings.opens_to_upgrade < previous_opens {
                panic!(
                    "PetCasesSettings level {}: opens_to_upgrade must be non-decreasing",
                    level_settings.level
                );
            }
            previous_level = level_settings.level;
            previous_opens = level_settings.opens_to_upgrade;

            // Boundary levels only need level + opens_to_upgrade; skip all other validations.
            if level_settings.is_boundary_level {
                continue;
            }

            // The drop pool: every roll on this level draws a rarity from these weights.
            if level_settings.rarity_weights.is_empty() {
                panic!(
                    "PetCasesSettings level {}: rarity_weights must not be empty",
                    level_settings.level
                );
            }
            // rarity_weight.weight > 0 enforced by PositiveF64 type
            for rarity_weight in &level_settings.rarity_weights {
                if !rarity_ids.contains(&rarity_weight.rarity_id) {
                    panic!(
                        "PetCasesSettings level {}: rarity weight rarity {} not found",
                        level_settings.level, rarity_weight.rarity_id
                    );
                }
            }

            let mut previous_checkpoint_opens = -1;
            for checkpoint in &level_settings.checkpoints {
                if checkpoint.required_opens <= 0 {
                    panic!(
                        "PetCasesSettings level {}: checkpoint required_opens must be > 0",
                        level_settings.level
                    );
                }
                if checkpoint.required_opens <= previous_checkpoint_opens {
                    panic!(
                        "PetCasesSettings level {}: checkpoint required_opens must be strictly increasing",
                        level_settings.level
                    );
                }
                previous_checkpoint_opens = checkpoint.required_opens;

                // Checkpoint required_opens is relative to the current level's
                // opens_to_upgrade. It must not exceed the range of this level
                // (i.e. the gap to the next level's opens_to_upgrade).
                if let Some(next) = settings_by_level.get(idx + 1) {
                    let level_range = next.opens_to_upgrade - level_settings.opens_to_upgrade;
                    if checkpoint.required_opens > level_range {
                        panic!(
                            "PetCasesSettings level {}: checkpoint required_opens ({}) exceeds level range ({})",
                            level_settings.level, checkpoint.required_opens, level_range
                        );
                    }
                }

                for currency_reward in &checkpoint.currency_rewards {
                    if currency_reward.amount <= 0 {
                        panic!(
                            "PetCasesSettings level {}: checkpoint currency reward must be > 0",
                            level_settings.level
                        );
                    }
                    if !currency_ids.contains(&currency_reward.currency_id) {
                        panic!(
                            "PetCasesSettings level {}: checkpoint currency {} not found",
                            level_settings.level, currency_reward.currency_id
                        );
                    }
                }

                for pet_reward in &checkpoint.pet_rewards {
                    if pet_reward.amount < 0 {
                        panic!(
                            "PetCasesSettings level {}: checkpoint pet reward amount must be >= 0",
                            level_settings.level
                        );
                    }
                    if pet_reward.amount > 0 && !rarity_ids.contains(&pet_reward.min_rarity_id) {
                        panic!(
                            "PetCasesSettings level {}: checkpoint pet reward min_rarity_id {} not found",
                            level_settings.level, pet_reward.min_rarity_id
                        );
                    }
                }
            }

            for rarity_id in &level_settings.allowed_wishlist_rarity_ids {
                if !rarity_ids.contains(rarity_id) {
                    panic!(
                        "PetCasesSettings level {}: allowed wishlist rarity {} not found",
                        level_settings.level, rarity_id
                    );
                }
            }

            for currency_reward in &level_settings.big_roll_currency_rewards {
                if currency_reward.amount <= 0 {
                    panic!(
                        "PetCasesSettings level {}: big-roll currency reward amount must be > 0",
                        level_settings.level
                    );
                }
                if !currency_ids.contains(&currency_reward.currency_id) {
                    panic!(
                        "PetCasesSettings level {}: big-roll currency {} not found",
                        level_settings.level, currency_reward.currency_id
                    );
                }
            }

            let big_roll_shards = &level_settings.big_roll_shards;
            let shards_total: u64 = big_roll_shards.iter().map(|s| s.count as u64).sum();
            let expected_total =
                gacha.big_roll_cost.get() as u64 + gacha.big_roll_bonus_drops as u64;
            if shards_total != expected_total {
                panic!(
                    "PetCasesSettings level {}: big_roll_shards total ({}) must equal big_roll_cost + bonus_drops ({})",
                    level_settings.level, shards_total, expected_total
                );
            }
            for shard in big_roll_shards {
                if shard.count == 0 {
                    panic!(
                        "PetCasesSettings level {}: big_roll_shards count must be > 0",
                        level_settings.level
                    );
                }
                if !rarity_ids.contains(&shard.min_rarity_id) {
                    panic!(
                        "PetCasesSettings level {}: big_roll_shards rarity {} not found",
                        level_settings.level, shard.min_rarity_id
                    );
                }
            }
        }

        if settings_by_level[0].level != 1 || settings_by_level[0].opens_to_upgrade != 0 {
            panic!("PetCasesSettings: level 1 with opens_to_upgrade = 0 is required");
        }
    }

    fn validate_statue_settings(&self) {
        use std::collections::HashSet;

        let statue = &self.statue_settings;
        let currency_ids: HashSet<_> = self.currencies.iter().map(|c| c.id).collect();
        let attribute_ids: HashSet<_> = self.attributes.iter().map(|a| a.id).collect();

        if !currency_ids.contains(&statue.currency_id) {
            panic!(
                "StatueSettings: currency_id {} not found in currencies",
                statue.currency_id
            );
        }

        // statue_bonus_grades non-empty enforced by NonEmptyVec type

        let grade_ids: HashSet<_> = self.statue_bonus_grades.iter().map(|g| g.id).collect();
        if grade_ids.len() != self.statue_bonus_grades.len() {
            panic!("statue_bonus_grades: duplicate grade ids");
        }

        // roll_costs non-empty enforced by NonEmptyVec type
        // roll_costs cost > 0 enforced by PositiveI64 type

        // statue_bonus_type_configs non-empty enforced by NonEmptyVec type
        for bonus_type in &self.statue_bonus_type_configs {
            if !attribute_ids.contains(&bonus_type.attribute_id) {
                panic!(
                    "statue_bonus_type_configs attribute_id {} not found in attributes",
                    bonus_type.attribute_id
                );
            }
            // grade_values non-empty enforced by NonEmptyVec type
            for grade_value in &bonus_type.grade_values {
                if !grade_ids.contains(&grade_value.grade_id) {
                    panic!(
                        "statue_bonus_type_configs attribute {} references unknown grade_id {}",
                        bonus_type.attribute_id, grade_value.grade_id
                    );
                }
                // grade_value.value > 0 enforced by PositiveI32 type
            }
        }

        // statue_level_configs non-empty enforced by NonEmptyVec type
        if self.statue_level_configs[0].level != 1
            || self.statue_level_configs[0].required_experience != 0
        {
            panic!("statue_level_configs must start with level=1 and required_experience=0");
        }
        let mut prev_level = 0;
        let mut prev_exp = -1;
        for level_config in &self.statue_level_configs {
            if level_config.level <= prev_level {
                panic!("statue_level_configs levels must be strictly increasing");
            }
            if level_config.required_experience <= prev_exp && level_config.level > 1 {
                panic!(
                    "statue_level_configs level={} required_experience must be strictly increasing",
                    level_config.level
                );
            }
            // slot_count > 0 enforced by NonZeroU64 type
            // sets_count > 0 enforced by NonZeroU64 type
            // grade_weights non-empty enforced by NonEmptyVec type
            for weight in &level_config.grade_weights {
                if !grade_ids.contains(&weight.grade_id) {
                    panic!(
                        "statue_level_configs level={} grade_weights references unknown grade_id {}",
                        level_config.level, weight.grade_id
                    );
                }
                // weight > 0 enforced by PositiveF64 type
            }
            prev_level = level_config.level;
            prev_exp = level_config.required_experience;
        }
    }

    fn has_unique_ids(items: &[ItemTemplate]) -> bool {
        let mut ids = std::collections::HashSet::new();
        items.iter().all(|item| ids.insert(item.id))
    }
}

#[derive(Debug, Clone, Copy)]
pub struct NextFightInfo {
    pub next_chapter_level: i64,
    pub next_fight_number: i64,
    pub next_fight_id: Option<essences::fighting::FightTemplateId>,
}

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub enum GetConfigResponse {
    Ok { config: Box<GameConfig> },
    Error { code: String, message: String },
}

#[cfg(test)]
mod tests {
    use super::*;
    use essences::offers::OfferTemplateId;
    use essences::progress_pass::{ProgressPassConfig, ProgressPassTierTemplate};
    use essences::ratings::RatingType;
    use uuid::uuid;

    fn tier(tier: u32, quest_template_ids: Vec<uuid::Uuid>) -> ProgressPassTierTemplate {
        ProgressPassTierTemplate {
            tier,
            quest_template_ids,
            free_reward_bundle_id: uuid::Uuid::nil(),
            paid_reward_bundle_id: uuid::Uuid::nil(),
        }
    }

    fn pp_config(tiers: Vec<ProgressPassTierTemplate>) -> ProgressPassConfig {
        ProgressPassConfig {
            tiers,
            premium_offer_template_id: OfferTemplateId::nil(),
        }
    }

    #[test]
    fn validate_dungeon_templates_accepts_missing_and_positive_overrides() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_dungeon_templates();

        config.dungeon_templates[0].between_wave_spawn_delay_ticks = Some(100);
        config.dungeon_templates[0].advance_formation_between_waves = Some(false);
        config.validate_dungeon_templates();
    }

    #[test]
    #[should_panic(expected = "between_wave_spawn_delay_ticks must be > 0 when set")]
    fn validate_dungeon_templates_rejects_zero_spawn_delay() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.dungeon_templates[0].between_wave_spawn_delay_ticks = Some(0);
        config.validate_dungeon_templates();
    }

    #[test]
    fn validate_portal_rarities_accepts_valid_config() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_portal_rarities();
    }

    #[test]
    #[should_panic(expected = "PortalRarities: duplicate id")]
    fn validate_portal_rarities_rejects_duplicate_ids() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let mut duplicate = config.portal_rarities[1].clone();
        duplicate.id = config.portal_rarities[0].id;
        config.portal_rarities.push(duplicate);

        config.validate_portal_rarities();
    }

    #[test]
    #[should_panic(expected = "PortalRarities: duplicate item_rarity_id")]
    fn validate_portal_rarities_rejects_duplicate_item_rarity_mappings() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.portal_rarities[1].item_rarity_id = config.portal_rarities[0].item_rarity_id;

        config.validate_portal_rarities();
    }

    #[test]
    #[should_panic(expected = "not found in item_rarities")]
    fn validate_portal_rarities_rejects_missing_item_rarity_links() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.portal_rarities[0].item_rarity_id = uuid::Uuid::nil();

        config.validate_portal_rarities();
    }

    #[test]
    #[should_panic(expected = "icon_path must not be empty")]
    fn validate_portal_rarities_rejects_empty_icon_paths() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.portal_rarities[0].icon_path = "  ".to_string();

        config.validate_portal_rarities();
    }

    #[test]
    fn validate_portal_rarities_rejects_missing_plinko_rarity_mapping() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        let rarity_ids: std::collections::HashSet<_> = config
            .plinko_settings
            .slot_layouts
            .iter()
            .flat_map(|layout| layout.slot_groups.iter())
            .map(|group| group.rarity_id)
            .collect();

        for rarity_id in rarity_ids {
            let mut config = crate::tests_game_config::generate_game_config_for_tests();
            config
                .portal_rarities
                .retain(|portal_rarity| portal_rarity.item_rarity_id != rarity_id);

            let panic = std::panic::catch_unwind(|| config.validate_portal_rarities())
                .expect_err("every Plinko-used rarity must have a portal mapping");
            let message = panic
                .downcast_ref::<String>()
                .expect("validator panics with an owned message");
            assert_eq!(
                message,
                &format!(
                    "PortalRarities: missing mapping for item rarity {rarity_id} referenced by plinko_settings.slot_layouts"
                )
            );
        }
    }

    #[test]
    fn validate_progress_pass_accepts_valid_config() {
        let config = pp_config(vec![
            tier(1, vec![uuid!("aa000000-0000-0000-0000-000000000001")]),
            tier(
                2,
                vec![
                    uuid!("aa000000-0000-0000-0000-000000000001"),
                    uuid!("bb000000-0000-0000-0000-000000000002"),
                ],
            ),
            tier(3, vec![uuid!("cc000000-0000-0000-0000-000000000003")]),
        ]);
        GameConfig::validate_progress_pass_config(&config);
    }

    #[test]
    fn validate_progress_pass_accepts_empty_tiers() {
        let config = pp_config(vec![]);
        GameConfig::validate_progress_pass_config(&config);
    }

    #[test]
    #[should_panic(expected = "ProgressPassConfig: tier 2 has no quest_template_ids")]
    fn validate_progress_pass_rejects_empty_quest_template_ids() {
        let config = pp_config(vec![
            tier(1, vec![uuid!("aa000000-0000-0000-0000-000000000001")]),
            tier(2, vec![]),
        ]);
        GameConfig::validate_progress_pass_config(&config);
    }

    #[test]
    #[should_panic(expected = "ProgressPassConfig: duplicate tier value 1")]
    fn validate_progress_pass_rejects_duplicate_tier_numbers() {
        let config = pp_config(vec![
            tier(1, vec![uuid!("aa000000-0000-0000-0000-000000000001")]),
            tier(1, vec![uuid!("bb000000-0000-0000-0000-000000000002")]),
        ]);
        GameConfig::validate_progress_pass_config(&config);
    }

    #[test]
    fn validate_cores_settings_accepts_test_config() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_cores_settings();
    }

    #[test]
    #[should_panic(expected = "unlock_essence_grant must be >= 0")]
    fn validate_cores_settings_rejects_negative_unlock_grant() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.cores_settings.unlock_essence_grant = -1;
        config.validate_cores_settings();
    }

    /// The coupled trio (slot cap / slot ladder / bridge limit). Stretching the
    /// slot ladder to a slot every TWO levels pushes the allowed bridge count
    /// (`min(level, max_slot_level) - 1` = 9) past the physically possible one
    /// (5 slots), and the "which bridges do I keep" choice disappears — the
    /// validator must refuse it.
    ///
    /// That two-levels-per-slot pair is exactly the pre-v0.2 configuration the
    /// artifact right column refitted away from, so this is a real regression
    /// guard rather than an invented one.
    ///
    /// It no longer trips by raising `max_core_level`: core levels are unbounded
    /// now, and `max_bridges` clamps at the slot level precisely so that a level
    /// past the slot ladder cannot buy a bridge. Raising the cap alone leaving
    /// this assert quiet IS the fix working.
    #[test]
    #[should_panic(expected = "the slot cap, the slot ladder and the bridge limit move together")]
    fn validate_cores_settings_rejects_slot_ladder_that_kills_the_bridge_choice() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.cores_settings.core_levels_per_slot = crate::validated_types::PositiveI64::new(2);
        config.validate_cores_settings();
    }

    /// ...and the complement: an unbounded level cap on its own is legal, which
    /// is the whole point of the clamp. Without it this config would report 49
    /// allowed bridges against 5 possible.
    #[test]
    fn validate_cores_settings_accepts_a_level_cap_far_above_the_slot_ladder() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.cores_settings.max_core_level = 9_999;
        config.validate_cores_settings();
    }

    /// A HOLE in the cost table. `core_level_cost` refuses to price a gap rather
    /// than inventing a neighbour's value, so a ladder with one missing rung
    /// would dead-end below the cap.
    #[test]
    #[should_panic(expected = "level_costs must be a contiguous run of levels starting at 2")]
    fn validate_cores_settings_rejects_gap_in_the_level_ladder() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let levels: Vec<_> = config
            .cores_settings
            .level_costs
            .iter()
            .filter(|row| row.level != 3)
            .cloned()
            .collect();
        config.cores_settings.level_costs = NonEmptyVec::new(levels);
        config.validate_cores_settings();
    }

    /// Truncating the table below the last SLOT-opening level is a different
    /// failure from a hole: the run stays contiguous, but a level that opens a
    /// slot would be priced by the geometric extension instead of by the
    /// designer. The extension exists for the levels past the ladder, not for
    /// the ones the design owns.
    #[test]
    #[should_panic(expected = "slots keep opening until")]
    fn validate_cores_settings_rejects_an_unpriced_slot_level() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let levels: Vec<_> = config
            .cores_settings
            .level_costs
            .iter()
            .filter(|row| row.level != 5)
            .cloned()
            .collect();
        config.cores_settings.level_costs = NonEmptyVec::new(levels);
        config.validate_cores_settings();
    }

    #[test]
    #[should_panic(expected = "law_upgrade_ladder must be a contiguous run starting at level 2")]
    fn validate_cores_settings_rejects_ladder_with_a_hole() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let ladder: Vec<_> = config
            .cores_settings
            .law_upgrade_ladder
            .iter()
            .filter(|row| row.level != 3)
            .cloned()
            .collect();
        config.cores_settings.law_upgrade_ladder = NonEmptyVec::new(ladder);
        config.validate_cores_settings();
    }

    /// The charge trio is a PAIR since the artifact right column: the cap and
    /// the capacity move independently, because `BL-03 Short Span` moves them by
    /// different amounts. Any pair of positive numbers is now legal, and the
    /// amplification a given charge is worth follows from the two.
    #[test]
    fn a_bridge_cap_no_longer_has_to_match_the_capacity() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config
            .cores_settings
            .bridge_charge
            .amplification_cap_permyriad = crate::validated_types::PositiveI64::new(9_000);
        config.validate_cores_settings();

        // And the pair prices amplification as a share of fullness.
        let settings = &config.cores_settings;
        assert!((settings.law_power_multiplier(10) - 1.90).abs() < 1e-9);
        assert!((settings.law_power_multiplier(5) - 1.45).abs() < 1e-9);
        assert!(
            (settings.law_power_multiplier(40) - 1.90).abs() < 1e-9,
            "past capacity the multiplier must not keep climbing"
        );
    }

    /// A timed effect with no duration would never expire and would become a
    /// permanent stat instead of a law fire.
    #[test]
    #[should_panic(expected = "is timed and needs a non-zero effect_duration_ticks")]
    fn validate_cores_settings_rejects_a_timed_effect_with_no_duration() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        for law in &mut config.laws {
            if law.effect.is_timed() {
                law.effect_duration_ticks = 0;
            }
        }
        config.validate_cores_settings();
    }

    #[test]
    #[should_panic(expected = "multiplied_attribute_ids references unknown attribute")]
    fn validate_cores_settings_rejects_unknown_multiplied_attribute() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.cores_settings.multiplied_attribute_ids =
            vec![uuid!("ffffffff-0000-0000-0000-000000000001")];
        config.validate_cores_settings();
    }

    #[test]
    fn validate_pet_gacha_settings_accepts_test_config() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_pet_gacha_settings();
    }

    #[test]
    fn validate_item_cases_settings_accepts_test_config() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_item_cases_settings();
    }

    #[test]
    fn validate_flip_settings_accepts_test_config() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_flip_settings();
    }

    #[test]
    #[should_panic(expected = "unlock_chapter must be >= 0")]
    fn validate_flip_settings_rejects_negative_unlock_chapter() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.flip_settings.unlock_chapter = -1;
        config.validate_flip_settings();
    }

    #[test]
    #[should_panic(expected = "progress_threshold must be finite and > 0")]
    fn validate_flip_settings_rejects_non_positive_threshold() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.flip_settings.progress_threshold = 0.0;
        config.validate_flip_settings();
    }

    #[test]
    fn validate_artifacts_accepts_test_config() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_artifacts();
    }

    #[test]
    #[should_panic(expected = "must share the same unlock_chapter")]
    fn validate_artifacts_rejects_a_gate_that_drifts_from_cores() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.artifacts_settings.unlock_chapter = config.cores_settings.unlock_chapter + 1;
        config.validate_artifacts();
    }

    #[test]
    #[should_panic(expected = "ownership bonus references unknown attribute")]
    fn validate_artifacts_rejects_an_ownership_bonus_on_a_missing_attribute() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.artifacts[0].ownership_bonuses[0].attribute_id = uuid::Uuid::from_u128(0xDEAD);
        config.validate_artifacts();
    }

    /// A bonus is written as `<code>.mod`, and only the codes the runtime
    /// composes are ever read back. `strength` is in the fixture catalog but
    /// nothing composes `strength.mod`, so a bonus on it would be stored,
    /// displayed nowhere and read by nothing — inert content that looks
    /// configured. The validator refuses it instead of shipping it.
    #[test]
    #[should_panic(expected = "whose `.mod` is composed by nothing")]
    fn validate_artifacts_rejects_an_ownership_bonus_on_a_non_mod_capable_attribute() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let strength = config
            .attributes
            .iter()
            .find(|attribute| attribute.code == "strength")
            .expect("the fixture ships a non-mod-capable attribute")
            .id;
        assert!(
            !crate::artifacts::MOD_CAPABLE_ATTRIBUTE_CODES.contains(&"strength"),
            "this test is only meaningful while `strength` stays non-mod-capable"
        );
        config.artifacts[0].ownership_bonuses[0].attribute_id = strength;
        config.validate_artifacts();
    }

    /// Two rows on one attribute inside ONE artifact: the second one's intent is
    /// invisible (they would silently add), so the designer is told to merge them.
    #[test]
    #[should_panic(expected = "listed twice in ownership_bonuses")]
    fn validate_artifacts_rejects_two_ownership_bonuses_on_one_attribute() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let duplicate = config.artifacts[0].ownership_bonuses[0];
        config.artifacts[0].ownership_bonuses.push(duplicate);
        config.validate_artifacts();
    }

    /// ...but two DIFFERENT artifacts naming the same attribute is legal and
    /// meaningful — they add up over the collection, which is what makes a
    /// second artifact worth owning.
    #[test]
    fn validate_artifacts_accepts_two_artifacts_sharing_an_attribute() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let shared = config.artifacts[0].ownership_bonuses[0];
        config.artifacts[1].ownership_bonuses = vec![shared];
        config.validate_artifacts();
    }

    #[test]
    #[should_panic(expected = "ownership bonus percentages must be finite and >= 0")]
    fn validate_artifacts_rejects_a_negative_ownership_percent() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.artifacts[0].ownership_bonuses[0].percent = -1.0;
        config.validate_artifacts();
    }

    #[test]
    #[should_panic(expected = "ownership bonus percentages must be finite and >= 0")]
    fn validate_artifacts_rejects_a_non_finite_ownership_percent_per_level() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.artifacts[0].ownership_bonuses[0].percent_per_level = f64::NAN;
        config.validate_artifacts();
    }

    /// The guard the `MOD_CAPABLE_ATTRIBUTE_CODES` doc comment promises: every
    /// non-`.mod` attribute the fixture catalog ships is either mod-capable (so
    /// a designer may put a bonus on it) or deliberately absent from the list.
    ///
    /// It cannot assert full coverage — the fixture carries test-only attributes
    /// (`strength`, `agility`, `damage`) that the shipped game does not — so it
    /// asserts the direction that actually matters: the codes the SHIPPED game
    /// composes are all listed. `hp` and `armor` are the two the fixture and the
    /// shipped catalog share, and both must be usable.
    #[test]
    fn mod_capable_codes_cover_the_attributes_the_runtime_composes() {
        for code in ["hp", "armor", "attack"] {
            assert!(
                crate::artifacts::MOD_CAPABLE_ATTRIBUTE_CODES.contains(&code),
                "'{code}' is composed as `{code}.mod` by combat or the power scalar, so an \
                 ownership bonus on it must be allowed"
            );
        }
        let mut seen = std::collections::HashSet::new();
        for code in crate::artifacts::MOD_CAPABLE_ATTRIBUTE_CODES {
            assert!(seen.insert(code), "'{code}' listed twice");
            assert!(
                !code.ends_with(".mod"),
                "'{code}' is already a `.mod` key — the list holds BASE codes"
            );
        }
    }

    #[test]
    fn validate_stones_accepts_test_config() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_stones();
    }

    #[test]
    #[should_panic(expected = "unknown stat attribute id")]
    fn validate_stones_rejects_a_stat_on_a_missing_attribute() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.trigger_stones[0].stats[0].attribute_id = uuid::Uuid::from_u128(0xDEAD);
        config.validate_stones();
    }

    #[test]
    #[should_panic(expected = "unknown stat attribute id")]
    fn validate_stones_checks_effect_stone_stats_too() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.effect_stones[0].stats[0].attribute_id = uuid::Uuid::from_u128(0xDEAD);
        config.validate_stones();
    }

    #[test]
    #[should_panic(expected = "duplicate stat attribute id")]
    fn validate_stones_rejects_two_stats_on_one_attribute() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let duplicate = config.trigger_stones[0].stats[0];
        config.trigger_stones[0].stats.push(duplicate);
        config.validate_stones();
    }

    #[test]
    #[should_panic(expected = "must grant at least one stat")]
    fn validate_stones_rejects_an_empty_stat_block() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.effect_stones[0].stats.clear();
        config.validate_stones();
    }

    /// The duplicate rule is per stone: two different stones sharing an
    /// attribute is the normal case (every trigger in the shipped catalog
    /// grants `hp`), and pins the `seen_attrs.clear()` in `validate_stones`.
    #[test]
    fn validate_stones_allows_two_stones_to_share_an_attribute() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let shared = config.trigger_stones[0].stats[0];
        config.trigger_stones[1].stats = vec![shared];
        config.effect_stones[0].stats = vec![shared];
        config.validate_stones();
    }

    /// A gap in the ladder reads as "already at the cap" at runtime, so it must
    /// not survive a deploy.
    #[test]
    #[should_panic(expected = "upgrade_ladder has no cost for level")]
    fn validate_stones_rejects_a_gap_in_the_upgrade_ladder() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config
            .stones_settings
            .upgrade_ladder
            .retain(|step| step.level != 3);
        config.validate_stones();
    }

    /// The ladder must reach `max_stone_level`: raising the cap without pricing
    /// the new levels is the same gap by another route.
    #[test]
    #[should_panic(expected = "upgrade_ladder has no cost for level")]
    fn validate_stones_rejects_a_ladder_short_of_the_maximum_level() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.stones_settings.max_stone_level += 1;
        config.validate_stones();
    }

    #[test]
    #[should_panic(expected = "outside 2..=")]
    fn validate_stones_rejects_a_rung_past_the_maximum_level() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let max = config.stones_settings.max_stone_level;
        config
            .stones_settings
            .upgrade_ladder
            .push(crate::stones::StoneUpgradeStep {
                level: max + 1,
                copies: 2,
            });
        config.validate_stones();
    }

    #[test]
    #[should_panic(expected = "is priced twice")]
    fn validate_stones_rejects_a_level_priced_twice() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config
            .stones_settings
            .upgrade_ladder
            .push(crate::stones::StoneUpgradeStep {
                level: 2,
                copies: 7,
            });
        config.validate_stones();
    }

    #[test]
    #[should_panic(expected = "must cost at least one copy")]
    fn validate_stones_rejects_a_free_level() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.stones_settings.upgrade_ladder[0].copies = 0;
        config.validate_stones();
    }

    #[test]
    fn validate_item_world_sides_accepts_test_catalog() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_item_world_sides();
    }

    #[test]
    #[should_panic(expected = "must define world_side")]
    fn validate_item_world_sides_rejects_missing_side_on_flip_type() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let item = config
            .items
            .iter_mut()
            .find(|item| item.item_type.supports_world_side())
            .unwrap();
        item.world_side = None;
        config.validate_item_world_sides();
    }

    #[test]
    #[should_panic(expected = "must not define world_side")]
    fn validate_item_world_sides_rejects_side_on_fixed_type() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let item = config
            .items
            .iter_mut()
            .find(|item| !item.item_type.supports_world_side())
            .unwrap();
        item.world_side = Some(essences::flip::WorldSide::Real);
        config.validate_item_world_sides();
    }

    #[test]
    fn validate_inventory_levels_accepts_test_config() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_inventory_levels();
    }

    #[test]
    #[should_panic(expected = "must define world_side")]
    fn validate_inventory_levels_rejects_flip_slot_without_side() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let slot = config.inventory_levels[0]
            .slots
            .iter_mut()
            .find(|slot| slot.item_type.supports_world_side())
            .unwrap();
        slot.world_side = None;
        config.validate_inventory_levels();
    }

    #[test]
    #[should_panic(expected = "must not define world_side")]
    fn validate_inventory_levels_rejects_side_on_fixed_slot() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let slot = config.inventory_levels[0]
            .slots
            .iter_mut()
            .find(|slot| !slot.item_type.supports_world_side())
            .unwrap();
        slot.world_side = Some(essences::flip::WorldSide::Real);
        config.validate_inventory_levels();
    }

    #[test]
    #[should_panic(expected = "must not unlock Real slots before")]
    fn validate_inventory_levels_rejects_unlock_drift() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.flip_settings.unlock_chapter = 3;
        config.validate_inventory_levels();
    }

    #[test]
    fn validate_rating_rewards_accepts_test_config() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_rating_rewards();
    }

    #[test]
    #[should_panic(expected = "Power rating rewards must be empty")]
    fn validate_rating_rewards_rejects_daily_power_rewards() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let daily = config
            .ratings_settings
            .iter()
            .find(|settings| settings.rating_type == RatingType::Arena)
            .unwrap()
            .daily_rating_range_rewards[0]
            .clone();
        config
            .ratings_settings
            .iter_mut()
            .find(|settings| settings.rating_type == RatingType::Power)
            .unwrap()
            .daily_rating_range_rewards
            .push(daily);
        config.validate_rating_rewards();
    }

    #[test]
    #[should_panic(expected = "Power rating rewards must be empty")]
    fn validate_rating_rewards_rejects_weekly_power_rewards() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let weekly = config
            .ratings_settings
            .iter()
            .find(|settings| settings.rating_type == RatingType::Arena)
            .unwrap()
            .weekly_rating_range_rewards[0]
            .clone();
        config
            .ratings_settings
            .iter_mut()
            .find(|settings| settings.rating_type == RatingType::Power)
            .unwrap()
            .weekly_rating_range_rewards
            .push(weekly);
        config.validate_rating_rewards();
    }

    #[test]
    #[should_panic(expected = "reward ranges must not overlap")]
    fn validate_rating_rewards_rejects_overlapping_ranges() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let arena = config
            .ratings_settings
            .iter_mut()
            .find(|settings| settings.rating_type == RatingType::Arena)
            .unwrap();
        let mut overlapping = arena.daily_rating_range_rewards[0].clone();
        overlapping.diapason_end = Some(overlapping.diapason_start);
        arena.daily_rating_range_rewards.push(overlapping);
        config.validate_rating_rewards();
    }

    #[test]
    #[should_panic(expected = "must be exactly 1:5 of weekly")]
    fn validate_rating_rewards_rejects_wrong_daily_weekly_ratio() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let daily_bundle_id = config
            .ratings_settings
            .iter()
            .find(|settings| settings.rating_type == RatingType::Arena)
            .unwrap()
            .daily_rating_range_rewards[0]
            .bundle_id;
        let bundle = config
            .bundles
            .iter_mut()
            .find(|bundle| bundle.id == daily_bundle_id)
            .unwrap();
        bundle.steps[0].currencies[0].amount += 1;
        config.validate_rating_rewards();
    }

    #[test]
    fn validate_plinko_settings_accepts_test_config() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_plinko_settings();
    }

    /// Каждый уровень сундука обязан подписать все свои редкости: без слота
    /// сервер не сможет уронить шарик под выданный предмет.
    #[test]
    fn every_chest_level_labels_every_rarity_it_drops() {
        let config = crate::tests_game_config::generate_game_config_for_tests();

        for settings in &config.item_cases_settings {
            let layout = config
                .plinko_settings
                .layout_for_level(settings.level)
                .unwrap_or_else(|| panic!("chest level {} has no plinko board", settings.level));

            for weight in &settings.rarity_weights {
                if weight.weight <= 0.0 {
                    continue;
                }
                assert!(
                    layout
                        .slot_groups
                        .iter()
                        .any(|group| group.rarity_id == weight.rarity_id),
                    "chest level {} drops rarity {} but its board has no slot for it",
                    settings.level,
                    weight.rarity_id
                );
            }
        }
    }

    /// Тир редкости, которой подписан слот. Читается ПРЯМО из `slot_groups`,
    /// а не через хелперы поиска слота, — иначе утверждение проверяло бы само
    /// себя.
    fn plinko_slot_tier(config: &GameConfig, chest_level: i64, slot: i64) -> i64 {
        let layout = config
            .plinko_settings
            .layout_for_level(chest_level)
            .unwrap_or_else(|| panic!("chest level {chest_level} has no plinko board"));
        let rarity_id = layout
            .slot_groups
            .iter()
            .find(|group| slot >= group.from_slot && slot <= group.to_slot)
            .map(|group| group.rarity_id)
            .unwrap_or_else(|| panic!("chest level {chest_level} slot {slot} carries no label"));
        config
            .item_rarities
            .iter()
            .find(|rarity| rarity.id == rarity_id)
            .map(|rarity| rarity.order)
            .expect("the label names a known rarity")
    }

    /// Тир не убывает от центра к краю по обеим половинам доски — на каждом
    /// уровне сундука. Немонотонная раскладка врёт игроку, который читает
    /// доску как «к краям редкость растёт».
    #[test]
    fn every_board_grows_in_tier_from_the_centre_outwards() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        let rows = config.plinko_settings.rows;
        let left_centre = (config.plinko_settings.slot_count() - 1) / 2;
        let right_centre = config.plinko_settings.slot_count() / 2;

        for settings in &config.item_cases_settings {
            let level = settings.level;
            for slot in (1..=left_centre).rev() {
                assert!(
                    plinko_slot_tier(&config, level, slot - 1)
                        >= plinko_slot_tier(&config, level, slot),
                    "chest level {level}: tier drops from slot {slot} to the outer slot {}",
                    slot - 1
                );
            }
            for slot in right_centre..rows {
                assert!(
                    plinko_slot_tier(&config, level, slot + 1)
                        >= plinko_slot_tier(&config, level, slot),
                    "chest level {level}: tier drops from slot {slot} to the outer slot {}",
                    slot + 1
                );
            }
        }
    }

    /// Редкостей столько же, сколько пар слотов → доска полностью симметрична:
    /// каждая редкость держит пару, самый низкий тир — центр.
    #[test]
    fn a_board_with_one_rarity_per_pair_is_symmetric() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        let last_slot = config.plinko_settings.rows;
        let pairs = config.plinko_settings.slot_count() / 2;

        let level = config
            .item_cases_settings
            .iter()
            .find(|settings| {
                settings
                    .rarity_weights
                    .iter()
                    .filter(|weight| weight.weight > 0.0)
                    .count() as i64
                    == pairs
            })
            .map(|settings| settings.level)
            .expect("the fixture has a chest level dropping exactly one rarity per slot pair");

        for slot in 0..=last_slot {
            assert_eq!(
                plinko_slot_tier(&config, level, slot),
                plinko_slot_tier(&config, level, last_slot - slot),
                "chest level {level}: slot {slot} and its mirror carry different tiers"
            );
        }
        // Каждый тир занимает ровно пару слотов.
        for pair in 0..pairs {
            let inner = last_slot / 2 - pair;
            assert_eq!(
                plinko_slot_tier(&config, level, inner),
                plinko_slot_tier(&config, level, last_slot - inner),
                "chest level {level}: pair {pair} is not one tier"
            );
        }
    }

    /// Редкостей больше, чем пар слотов → лишние занимают крайние слоты по
    /// одной, и самый высокий тир достаётся последнему слоту, предыдущий по
    /// тиру — слоту 0. Именно эта форма живёт на боевых уровнях с пятью
    /// редкостями.
    #[test]
    fn a_board_with_more_rarities_than_pairs_splits_the_outer_slots() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        let last_slot = config.plinko_settings.rows;
        let pairs = config.plinko_settings.slot_count() / 2;

        let levels: Vec<_> = config
            .item_cases_settings
            .iter()
            .filter(|settings| {
                let dropped = settings
                    .rarity_weights
                    .iter()
                    .filter(|weight| weight.weight > 0.0)
                    .count() as i64;
                dropped > pairs && dropped < config.plinko_settings.slot_count()
            })
            .collect();
        assert!(
            !levels.is_empty(),
            "the fixture must have a chest level dropping more rarities than there are pairs"
        );

        for settings in levels {
            let level = settings.level;

            let mut tiers: Vec<i64> = settings
                .rarity_weights
                .iter()
                .filter(|weight| weight.weight > 0.0)
                .map(|weight| {
                    config
                        .item_rarities
                        .iter()
                        .find(|rarity| rarity.id == weight.rarity_id)
                        .map(|rarity| rarity.order)
                        .expect("rarity_weights name known rarities")
                })
                .collect();
            tiers.sort_unstable();

            assert_eq!(
                plinko_slot_tier(&config, level, last_slot),
                *tiers.last().expect("the level drops something"),
                "chest level {level}: the highest tier must own the last slot alone"
            );
            assert_ne!(
                plinko_slot_tier(&config, level, last_slot),
                plinko_slot_tier(&config, level, 0),
                "chest level {level}: the outer slots must not be one pair here"
            );
            assert_eq!(
                plinko_slot_tier(&config, level, 0),
                tiers[tiers.len() - 2],
                "chest level {level}: slot 0 must carry the tier just below the highest"
            );
            assert_eq!(
                plinko_slot_tier(&config, level, last_slot / 2),
                plinko_slot_tier(&config, level, last_slot / 2 + 1),
                "chest level {level}: the centre is still a pair"
            );
            assert_eq!(
                plinko_slot_tier(&config, level, last_slot / 2),
                tiers[0],
                "chest level {level}: the centre pair carries the lowest tier"
            );
        }
    }

    #[test]
    #[should_panic(expected = "the tier must not drop towards the edge")]
    fn validate_plinko_settings_rejects_a_non_monotonic_board() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        // Меняем местами центральную пару и соседнюю: более высокий тир
        // оказывается ближе к центру, чем более низкий.
        let level = config.item_cases_settings[0].level;
        let rows = config.plinko_settings.rows;
        let layout = (&mut config.plinko_settings.slot_layouts)
            .into_iter()
            .find(|layout| layout.chest_level == level)
            .expect("the fixture has a board for every chest level");

        let centre = rows / 2;
        let inner = layout.rarity_for_slot(centre).expect("centre is labelled");
        let outer = layout
            .rarity_for_slot(centre - 1)
            .expect("the slot next to the centre is labelled");
        let swapped: Vec<_> = layout
            .slot_groups
            .iter()
            .map(|group| {
                let mut group = group.clone();
                if group.rarity_id == inner {
                    group.rarity_id = outer;
                } else if group.rarity_id == outer {
                    group.rarity_id = inner;
                }
                group
            })
            .collect();
        layout.slot_groups = crate::validated_types::NonEmptyVec::new(swapped);

        config.validate_plinko_settings();
    }

    #[test]
    #[should_panic(expected = "has no slot for item rarity")]
    fn validate_plinko_settings_rejects_an_uncovered_rarity() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        // Отдаём весь первый уровень доски одной редкости: остальные редкости
        // этого уровня остаются без слота.
        let level = config.item_cases_settings[0].level;
        let rows = config.plinko_settings.rows;
        let layout = (&mut config.plinko_settings.slot_layouts)
            .into_iter()
            .find(|layout| layout.chest_level == level)
            .expect("the fixture has a board for every chest level");
        let rarity_id = layout.slot_groups.first().rarity_id;
        layout.slot_groups =
            crate::validated_types::NonEmptyVec::new(vec![crate::plinko::PlinkoSlotGroup {
                from_slot: 0,
                to_slot: rows,
                rarity_id,
                is_locked: false,
            }]);
        config.validate_plinko_settings();
    }

    #[test]
    #[should_panic(expected = "has no board for chest level")]
    fn validate_plinko_settings_rejects_a_chest_level_without_a_board() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let level = config.item_cases_settings[0].level;
        let kept: Vec<_> = config
            .plinko_settings
            .slot_layouts
            .iter()
            .filter(|layout| layout.chest_level != level)
            .cloned()
            .collect();
        config.plinko_settings.slot_layouts = crate::validated_types::NonEmptyVec::new(kept);
        config.validate_plinko_settings();
    }

    #[test]
    #[should_panic(expected = "auto_chest max_batch_size must never decrease with chest level")]
    fn validate_item_cases_settings_rejects_decreasing_batch_size() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        // Force the highest chest level's cap below its predecessor's.
        let last = config.item_cases_settings.len() - 1;
        config.item_cases_settings[last]
            .auto_chest_settings
            .max_batch_size = 0;
        config.validate_item_cases_settings();
    }

    /// The auto ladder is its own sequence and must be monotone in its own
    /// right — it used to ride the manual field, so nothing checked it.
    #[test]
    #[should_panic(expected = "auto_chest auto_only_max_batch_size must never decrease")]
    fn validate_item_cases_settings_rejects_decreasing_auto_batch_size() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let last = config.item_cases_settings.len() - 1;
        config.item_cases_settings[last]
            .auto_chest_settings
            .auto_only_max_batch_size = -1;
        config.validate_item_cases_settings();
    }

    /// Auto must stay the tighter ladder. Auto opens continuously, so a config
    /// where it exceeds the manual cap would make the automatic path the faster
    /// one — the opposite of the intended shape.
    #[test]
    #[should_panic(expected = "must not exceed")]
    fn validate_item_cases_settings_rejects_auto_above_manual() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let last = config.item_cases_settings.len() - 1;
        let manual = config.item_cases_settings[last]
            .auto_chest_settings
            .max_batch_size;
        config.item_cases_settings[last]
            .auto_chest_settings
            .auto_only_max_batch_size = manual + 1;
        config.validate_item_cases_settings();
    }

    #[test]
    #[should_panic(expected = "PetCasesSettings: must not be empty")]
    fn validate_pet_gacha_settings_rejects_empty_cases_settings() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings.clear();
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "PetCasesSettings: level 1 with opens_to_upgrade = 0 is required")]
    fn validate_pet_gacha_settings_rejects_missing_level_one() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings.remove(0);
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "rarity weight rarity")]
    fn validate_pet_gacha_settings_rejects_unknown_rarity_in_weights() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings[0].rarity_weights[0].rarity_id =
            uuid!("ffffffff-ffff-ffff-ffff-ffffffffffff");
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "rarity_weights must not be empty")]
    fn validate_pet_gacha_settings_rejects_empty_rarity_weights() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings[0].rarity_weights.clear();
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "must equal big_roll_cost + bonus_drops")]
    fn validate_pet_gacha_settings_rejects_shard_total_above_big_roll_drops() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings[0].big_roll_shards[0].count = 200;
        config.validate_pet_gacha_settings();
    }

    // Regression: live pet content shipped shard totals of 5 against a
    // big_roll_cost 5 + bonus 1, silently dropping the "+1" from every big roll.
    #[test]
    #[should_panic(expected = "must equal big_roll_cost + bonus_drops")]
    fn validate_pet_gacha_settings_rejects_shard_total_below_big_roll_drops() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings[0].big_roll_shards[0].count -= 1;
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "big_roll_shards rarity")]
    fn validate_pet_gacha_settings_rejects_unknown_shard_rarity() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings[0].big_roll_shards[0].min_rarity_id =
            uuid!("ffffffff-ffff-ffff-ffff-ffffffffffff");
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "checkpoint required_opens must be strictly increasing")]
    fn validate_pet_gacha_settings_rejects_non_increasing_checkpoints() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let checkpoint = config.pet_cases_settings[0].checkpoints[0].clone();
        config.pet_cases_settings[0].checkpoints.push(checkpoint);
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "PetGachaSettings: wishlist_slots must be > 0")]
    fn validate_pet_gacha_settings_rejects_zero_wishlist_slots() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.game_settings.pet_gacha.wishlist_slots = 0;
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "not found in pet_rarities")]
    fn validate_pet_config_rejects_unknown_pet_level_rarity() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_levels[0].rarity_id = uuid!("ffffffff-ffff-ffff-ffff-ffffffffffff");
        config.validate_pet_config();
    }
}