forge/

wowlab.rs

// #t(file: rust_alloc_in_loop) CLI binary, allocations are fine for readability.
// #t(file: rust_inline_test_module_size) private profile-to-intent tests exercise resolver-backed conversion helpers beside the implementation

#![expect(
    clippy::cast_possible_truncation,
    clippy::cast_possible_wrap,
    clippy::cast_precision_loss,
    reason = "protobuf telemetry counters and registered IDs are bounded by engine contracts and converted to comparison display fields"
)]

//! `WowlabProvider`: runs the engine in-process via `simulate_intent`.

use std::collections::BTreeMap;

use anyhow::{Context, Result, ensure};
#[cfg(test)]
use googletest::{Result as GtestResult, prelude::*};
use wowlab_common::{output, sim::intent::serialize_sim_config};
use wowlab_engine_adapter_data::{LocalCsvResolver, OverlayResolver};
use wowlab_engine_application::simulate_intent;
use wowlab_engine_domain::rotation::to_simc_key;
use wowlab_engine_ports::{
    DataResolver, DynDataResolver, NoopProgress, PermanentEnchantQuery, SpellId, content_catalog,
};
use wowlab_fs::file;
use wowlab_parsers::{Item, Profile, parse_simc};
use wowlab_types::{
    constants::MS_PER_SECOND,
    game::{GearEntry, GearSlot, SpecId},
    sim::FastMap,
};

use crate::{
    constants::{DEFAULT_SEED, DPS_SCALE, default_data_dir, engine_dir},
    encounter_fixture::EncounterFixture,
    provider::{CastEntry, ComparisonConfig, SimOutput, SimProvider, SpellResult},
    sim,
};

const MARKER_KIND_CAST: i32 = 2;
const TRINKET_ONE_ACTION_SLOT: u8 = 1;
const TRINKET_TWO_ACTION_SLOT: u8 = 2;
const AUTO_SHOT_SPELL_ID: u32 = 75;
const COBRA_SHOT_SPELL_ID: u32 = 193_455;
const CAT_MELEE_SPELL_ID: u32 = 6_603;
const FERAL_MOONFIRE_SPELL_ID: u32 = 155_625;

fn canonical_action_name(spec: SpecId, spell_id: u32, declared_name: &str) -> String {
    match (spec, spell_id) {
        (SpecId::Feral, CAT_MELEE_SPELL_ID) => "cat_melee".to_string(),
        (SpecId::Feral, FERAL_MOONFIRE_SPELL_ID) => "lunar_inspiration".to_string(),
        (_, AUTO_SHOT_SPELL_ID) => "auto_shot".to_string(),
        (_, COBRA_SHOT_SPELL_ID) => "cobra_shot".to_string(),
        _ => declared_name.to_string(),
    }
}

#[derive(Debug)]
pub(crate) struct WowlabProvider {
    encounter_fixture: Option<EncounterFixture>,
}

impl WowlabProvider {
    #[must_use]
    pub(crate) const fn new(encounter_fixture: Option<EncounterFixture>) -> Self {
        Self { encounter_fixture }
    }
}

impl SimProvider for WowlabProvider {
    fn name(&self) -> &'static str {
        "wowlab"
    }

    fn run(&self, config: &ComparisonConfig) -> Result<SimOutput> {
        run_engine(config, self.encounter_fixture)
    }
}

pub(crate) fn build_spell_name_map(spec: SpecId) -> Result<FastMap<u32, String>> {
    let catalog = content_catalog().context("engine content catalog is unavailable")?;
    let introspection = wowlab_engine_application::introspect_spec(catalog, spec)
        .context("failed to introspect spec")?;
    let capacity =
        introspection.spells.len() + introspection.auras.len() + introspection.auto_attacks.len();
    let mut map = FastMap::default();

    map.reserve(capacity);

    for spell in &introspection.spells {
        map.insert(
            spell.spell_id,
            canonical_action_name(spec, spell.spell_id, &spell.name),
        );
    }

    for aura in &introspection.auras {
        map.insert(
            aura.aura_id,
            canonical_action_name(spec, aura.aura_id, &aura.name),
        );
    }

    for aa in &introspection.auto_attacks {
        let name = if aa.is_pet {
            "pet_attack"
        } else {
            "auto_attack"
        };

        map.insert(aa.spell_id, canonical_action_name(spec, aa.spell_id, name));
    }

    // Hero-tree spells deal damage without being castable; their const names lowercase into SimC's action naming.

    if let Ok(descriptor) = content_catalog().and_then(|catalog| catalog.descriptor(spec)) {
        for tree in descriptor.metadata.hero_talent_trees {
            for &(name, id) in tree.spells {
                map.entry(id).or_insert_with(|| name.to_lowercase());
            }

            for &(name, id) in tree.auras {
                map.entry(id).or_insert_with(|| name.to_lowercase());
            }
        }

        for &(name, id) in descriptor.metadata.reported_spells {
            map.insert(id, name.to_string());
        }
    }

    Ok(map)
}

pub(crate) async fn enrich_spell_name_map(
    map: &mut FastMap<u32, String>,
    action_ids: impl IntoIterator<Item = u32>,
    resolver: &DynDataResolver<'_>,
) {
    for spell_id in action_ids {
        if map.contains_key(&spell_id) {
            continue;
        }

        let Ok(spell) = resolver.get_spell(SpellId::new(spell_id as i32)).await else {
            continue;
        };

        map.insert(spell_id, to_simc_key(spell.name.as_str()));
    }
}

fn simc_slot_slug(slot: GearSlot) -> Option<&'static str> {
    match slot {
        GearSlot::Shirt | GearSlot::Tabard => None,
        other => Some(other.slug()),
    }
}

struct ProfileIntentData {
    loadout: Option<String>,
    expansion_talents: BTreeMap<String, Vec<String>>,
    gear: Vec<GearEntry>,
    race: String,
    player_level: u16,
    player_expansion_id: u32,
    settings: BTreeMap<String, toml::Value>,
}

fn consumable_settings(extra: &FastMap<String, String>) -> BTreeMap<String, toml::Value> {
    let mut settings = BTreeMap::new();

    if let Some(potion) = extra.get("potion") {
        settings.insert("potion".to_string(), toml::Value::String(potion.clone()));
        settings.insert("pre_pot".to_string(), toml::Value::Boolean(true));
    }

    if let Some(flask) = extra.get("flask") {
        settings.insert("flask".to_string(), toml::Value::String(flask.clone()));
    }

    if let Some(food) = extra.get("food") {
        settings.insert("food".to_string(), toml::Value::String(food.clone()));
    }

    if let Some(augment) = extra.get("augmentation") {
        settings.insert(
            "augment_rune".to_string(),
            toml::Value::String(augment.clone()),
        );
    }

    settings
}

fn permanent_enchant_name_and_rank(enchant: &str) -> (&str, i32) {
    enchant
        .rsplit_once('_')
        .and_then(|(name, rank)| rank.parse().ok().map(|rank| (name, rank)))
        .unwrap_or((enchant, 0))
}

async fn resolve_named_enchant(
    enchant: &str,
    item_id: u32,
    resolver: &DynDataResolver<'_>,
) -> Result<Option<u32>> {
    if enchant == "disabled" {
        return Ok(None);
    }

    let dbc_item_id = i32::try_from(item_id).context("equipped item ID does not fit i32")?;
    let item = resolver
        .get_item(dbc_item_id)
        .await
        .with_context(|| format!("failed to resolve equipped item {item_id} for `{enchant}`"))?;
    let (name, rank) = permanent_enchant_name_and_rank(enchant);
    let query = PermanentEnchantQuery {
        tokenized_name: name.to_string(),
        rank,
        item_class: item.class_id,
        inventory_type: item.inventory_type,
        item_subclass: item.subclass_id,
    };
    let entry = resolver
        .find_permanent_enchant(&query)
        .await
        .with_context(|| format!("failed to resolve permanent enchant `{enchant}`"))?
        .with_context(|| {
            format!(
                "named SimC enchant `{enchant}` does not apply to item {item_id} \
                 (class {}, subclass {}, inventory type {})",
                item.class_id, item.subclass_id, item.inventory_type
            )
        })?;

    u32::try_from(entry.enchant_id)
        .context("resolved enchantment ID does not fit u32")
        .map(Some)
}

async fn profile_gear(
    equipment: Vec<Item>,
    resolver: &DynDataResolver<'_>,
) -> Result<Vec<GearEntry>> {
    let mut gear = Vec::with_capacity(equipment.len());

    for item in equipment {
        if simc_slot_slug(item.gear.slot).is_none() {
            continue;
        }

        let enchant_id = if let Some(enchant_id) = item.gear.enchant_id {
            Some(enchant_id)
        } else if let Some(enchant) = item.enchant.as_deref() {
            resolve_named_enchant(enchant, item.gear.id, resolver).await?
        } else {
            None
        };

        gear.push(GearEntry {
            slot: item.gear.slot,
            id: item.gear.id,
            bonus_ids: item.gear.bonus_ids,
            enchant_id,
            gem_ids: item.gear.gem_ids,
            crafted_stats: item.gear.crafted_stats,
            crafting_quality: item.gear.crafting_quality,
            drop_level: item.gear.drop_level,
            ilevel: item.gear.ilevel,
        });
    }

    Ok(gear)
}

async fn profile_intent_data(
    profile: Profile,
    resolver: &DynDataResolver<'_>,
) -> Result<ProfileIntentData> {
    let loadout = (!profile.talents.encoded.is_empty()).then_some(profile.talents.encoded);
    let gear = profile_gear(profile.equipment, resolver).await?;
    let player_level = u16::try_from(profile.character.level)
        .context("SimC profile player level does not fit u16")?;

    Ok(ProfileIntentData {
        loadout,
        expansion_talents: profile.expansion_talents,
        gear,
        race: profile.character.race,
        player_level,
        player_expansion_id: crate::intent::PLAYER_EXPANSION_ID,
        settings: consumable_settings(&profile.extra),
    })
}

async fn simc_profile_intent_data(
    config: &ComparisonConfig,
    resolver: &DynDataResolver<'_>,
) -> Result<ProfileIntentData> {
    let profile_path = crate::simc::simc_profile_path(config.spec)
        .ok_or_else(|| anyhow::anyhow!("no SimC profile for {}", config.spec.slug()))?;
    let profile_text = file::read_text(&profile_path)
        .with_context(|| format!("failed to read SimC profile {}", profile_path.display()))?;
    let profile = parse_simc(&profile_text).context("failed to parse SimC profile")?;

    profile_intent_data(profile, resolver).await
}

fn rotation_uses_trinket_slot(value: &serde_json::Value, slot: u8) -> bool {
    let mut pending = vec![value];

    while let Some(value) = pending.pop() {
        match value {
            serde_json::Value::Array(entries) => pending.extend(entries),
            serde_json::Value::Object(object) => {
                let is_match = object.get("type").and_then(serde_json::Value::as_str)
                    == Some("use_trinket")
                    && object.get("slot").and_then(serde_json::Value::as_u64)
                        == Some(u64::from(slot));

                if is_match {
                    return true;
                }

                pending.extend(object.values());
            }
            _ => {}
        }
    }

    false
}

fn add_registered_item_uses(
    rotation: &mut serde_json::Value,
    equipment: impl IntoIterator<Item = (GearSlot, u32)>,
) -> Result<()> {
    let mut slots = equipment
        .into_iter()
        .filter_map(|(slot, item_id)| {
            let slot_number = match slot {
                GearSlot::Trinket1 => TRINKET_ONE_ACTION_SLOT,
                GearSlot::Trinket2 => TRINKET_TWO_ACTION_SLOT,
                _ => return None,
            };

            wowlab_engine_content::registered_item_use_spell(item_id).map(|_| (slot, slot_number))
        })
        .filter(|&(_, slot_number)| !rotation_uses_trinket_slot(rotation, slot_number))
        .collect::<Vec<_>>();

    slots.sort_unstable_by_key(|&(_, slot_number)| slot_number);
    let actions = rotation
        .get_mut("actions")
        .and_then(serde_json::Value::as_array_mut)
        .context("assisted rotation has no top-level actions array")?;

    for (slot, slot_number) in slots.into_iter().rev() {
        let cooldown_key = slot
            .use_alias()
            .context("registered on-use item is not in an actionable gear slot")?;

        actions.insert(
            0,
            serde_json::json!({
                "type": "use_trinket",
                "slot": slot_number,
                "condition": {
                    "type": "read",
                    "domain": "cooldown",
                    "key": cooldown_key,
                    "name": "is_ready"
                }
            }),
        );
    }

    Ok(())
}

/// Full sim-intent TOML for `config`'s spec: the MID1 `SimC` profile's loadout and gear, plus fight settings.
pub(crate) async fn wowlab_profile_config(
    config: &ComparisonConfig,
    rotation_id: &str,
    resolver: &DynDataResolver<'_>,
) -> Result<String> {
    wowlab_profile_config_with_fixture(config, rotation_id, None, resolver).await
}

/// Full profile intent with an optional canonical Phase 8 encounter fixture.
pub(crate) async fn wowlab_profile_config_with_fixture(
    config: &ComparisonConfig,
    rotation_id: &str,
    encounter_fixture: Option<EncounterFixture>,
    resolver: &DynDataResolver<'_>,
) -> Result<String> {
    let profile = simc_profile_intent_data(config, resolver).await?;

    serialize_profile_config(config, rotation_id, encounter_fixture, profile)
}

fn serialize_profile_config(
    config: &ComparisonConfig,
    rotation_id: &str,
    encounter_fixture: Option<EncounterFixture>,
    profile: ProfileIntentData,
) -> Result<String> {
    ensure!(
        profile.player_level > 0,
        "SimC profile player level must be positive"
    );
    let race = config.race.as_deref().unwrap_or(&profile.race);
    let mut intent = crate::intent::canonical_patchwerk_intent(
        config.spec,
        rotation_id,
        f64::from(config.parameters.fight_duration_secs()),
    )
    .map_err(|message| anyhow::anyhow!("failed to build comparison intent: {message}"))?;

    intent.loadout = profile.loadout;
    intent.expansion_talents = profile.expansion_talents;
    intent.gear = profile.gear;
    intent.player_level = profile.player_level;
    intent.player_expansion_id = profile.player_expansion_id;
    intent.settings = profile.settings;

    if let Some(fixture) = encounter_fixture {
        intent.encounter = fixture.definition()?;
    }

    intent
        .settings
        .insert("race".to_string(), toml::Value::String(race.to_string()));

    if !config.bugs {
        intent
            .settings
            .insert("bugs".to_string(), toml::Value::Boolean(false));
    }

    serialize_sim_config(&intent).context("failed to serialize comparison intent")
}

// #t(rust_cyclomatic_complexity) sequential decode/resolve/timeline steps.
fn run_engine(
    config: &ComparisonConfig,
    encounter_fixture: Option<EncounterFixture>,
) -> Result<SimOutput> {
    let slug = config.spec.slug();
    let rotation_id = format!("{slug}_assisted");
    let data_dir = std::env::var("WOWLAB_DATA_DIR").unwrap_or_else(|_| default_data_dir());
    let rotation_path = engine_dir()
        .join("examples/rotations")
        .join(format!("{rotation_id}.json"));
    let rotation_script = file::read_text(&rotation_path)
        .with_context(|| format!("failed to read rotation {}", rotation_path.display()))?;
    let rotation_value: serde_json::Value = serde_json::from_str(&rotation_script)
        .with_context(|| format!("invalid rotation JSON {}", rotation_path.display()))?;
    let mut rotation_value = wowlab_parsers::apply_rotation_overlay(slug, &rotation_value)?;
    let profile_path = crate::simc::simc_profile_path(config.spec)
        .ok_or_else(|| anyhow::anyhow!("no SimC profile for {}", config.spec.slug()))?;
    let profile_text = file::read_text(&profile_path)
        .with_context(|| format!("failed to read SimC profile {}", profile_path.display()))?;
    let profile = parse_simc(&profile_text).context("failed to parse SimC profile")?;

    add_registered_item_uses(
        &mut rotation_value,
        profile
            .equipment
            .iter()
            .map(|item| (item.gear.slot, item.gear.id)),
    )?;
    let rotation_script = serde_json::to_string(&rotation_value)?;

    let resolver = OverlayResolver::new(LocalCsvResolver::new(data_dir.as_str()))
        .with_rotation_script(&rotation_id, rotation_script);
    let resolver_dyn = DynDataResolver::from_ref(&resolver);
    let catalog = content_catalog().context("engine content catalog is unavailable")?;
    let rt = tokio::runtime::Runtime::new().context("failed to create tokio runtime")?;
    let sim_config = rt.block_on(wowlab_profile_config_with_fixture(
        config,
        &rotation_id,
        encounter_fixture,
        resolver_dyn,
    ))?;
    let chunk = sim::make_chunk("compare", config.parameters.iterations(), None);

    output::detail(&format!(
        "Running wowlab ({} iter, {}s)...",
        config.parameters.iterations(),
        config.parameters.fight_duration_secs(),
    ));

    let report = rt
        .block_on(simulate_intent(
            catalog,
            &sim_config,
            &chunk,
            DEFAULT_SEED,
            resolver_dyn,
            &NoopProgress,
        ))
        .with_context(|| format!("simulation failed for {slug}"))?;

    let telemetry = sim::decode_telemetry(&report)?;

    trace_telemetry_summary(&telemetry);

    let mut name_map = build_spell_name_map(config.spec)?;

    rt.block_on(enrich_spell_name_map(
        &mut name_map,
        telemetry.actions.iter().map(|action| action.spell_id),
        resolver_dyn,
    ));
    let n = telemetry.iterations;
    let fight_time_s = telemetry.total_fight_time_ms as f64 / MS_PER_SECOND / f64::from(n);
    let total_dps = sim::mean_dps(&telemetry);

    let spells = collect_spell_results(&telemetry, &name_map, fight_time_s, total_dps);

    let mut timeline = Vec::new();

    if let Some(rep) = &telemetry.representative {
        let mut abs_ms: u32 = 0;

        for m in &rep.markers {
            abs_ms = abs_ms.saturating_add(m.delta_time_ms);

            if m.kind == MARKER_KIND_CAST {
                let spell_name = name_map
                    .get(&m.spell_or_aura_id)
                    .cloned()
                    .unwrap_or_else(|| format!("unk#{}", m.spell_or_aura_id));

                timeline.push(CastEntry {
                    time_secs: f64::from(abs_ms) / MS_PER_SECOND,
                    spell_name,
                });
            }
        }
    }

    let mut output = SimOutput::new(total_dps, spells, timeline);

    for row in &telemetry.resources {
        for source in &row.by_source {
            let name = match source.source_spell_id {
                wowlab_engine_telemetry::RESOURCE_SOURCE_UNATTRIBUTED => "unattributed".to_string(),
                wowlab_engine_telemetry::RESOURCE_SOURCE_AUTO_ATTACK => "auto_attack".to_string(),
                wowlab_engine_telemetry::RESOURCE_SOURCE_PASSIVE_REGEN => {
                    "passive_regen".to_string()
                }
                id => name_map
                    .get(&id)
                    .cloned()
                    .unwrap_or_else(|| format!("unk#{id}")),
            };
            let entry = output.resource_gains.entry(name).or_default();
            let iterations = f64::from(n.max(1));

            entry.gained += source.gained_x100 as f64
                / wowlab_types::constants::PROTO_RESOURCE_SCALE
                / iterations;
            entry.wasted += source.wasted_x100 as f64
                / wowlab_types::constants::PROTO_RESOURCE_SCALE
                / iterations;
        }
    }

    if let Some(fixture) = encounter_fixture {
        let encounter_debug = rt.block_on(crate::encounter_debug::build_report(
            fixture,
            &telemetry,
            resolver_dyn,
        ))?;

        Ok(output.with_encounter_debug(encounter_debug))
    } else {
        Ok(output)
    }
}

fn trace_telemetry_summary(telemetry: &wowlab_types::proto::ChunkTelemetry) {
    tracing::trace!(actions = ?telemetry.actions, "action telemetry summaries");
    tracing::trace!(auras = ?telemetry.auras, "aura telemetry summaries");
    tracing::trace!(cooldowns = ?telemetry.cooldowns, "cooldown telemetry summaries");
}

/// Per-spell rows from action telemetry, keyed by resolved spell name.
// #t(fn: rust_alloc_in_loop) CLI reporting builds one owned row per action; readability wins here
fn collect_spell_results(
    telemetry: &wowlab_types::proto::ChunkTelemetry,
    name_map: &FastMap<u32, String>,
    fight_time_s: f64,
    total_dps: f64,
) -> Vec<(String, SpellResult)> {
    let n = telemetry.iterations;
    let mut spells = Vec::with_capacity(telemetry.actions.len());

    for a in &telemetry.actions {
        let dmg = a.total_damage_x10 as f64 / DPS_SCALE;
        let dps = if fight_time_s > 0.0 && n > 0 {
            dmg / fight_time_s / f64::from(n)
        } else {
            0.0
        };
        let per_iteration = |total: u64| {
            if n > 0 {
                (total / u64::from(n)) as u32
            } else {
                0
            }
        };
        let avg_casts = per_iteration(a.casts);
        // Guardian, pet, and proc rows carry no casts; their damage still lands as hits and ticks.
        let avg_hits = per_iteration(a.direct_hits.saturating_add(a.ticks));

        if dps <= 0.0 && avg_casts == 0 {
            continue;
        }

        let pct = if total_dps > 0.0 {
            dps / total_dps
        } else {
            0.0
        };
        let name = name_map
            .get(&a.spell_id)
            .cloned()
            .unwrap_or_else(|| format!("unk#{}", a.spell_id));

        spells.push((
            name,
            SpellResult {
                dps,
                casts: avg_casts,
                hits: avg_hits,
                pct,
            },
        ));
    }

    spells
}

#[cfg(test)]
mod tests {
    use wowlab_common::sim::intent::{SimConfigIntent, parse_sim_config};
    use wowlab_engine_adapter_data::InMemoryResolver;
    use wowlab_types::{
        data::{ItemDataFlat, PermanentEnchantFlat},
        sim::{DifficultyContext, EnemyDefinition},
    };

    use super::*;
    use crate::run::{FightDurationSeconds, IterationCount, RunParameters};

    const FERAL_TEST_PROFILE: &str = "druid=\"Test\"\n\
        spec=feral\n\
        level=90\n\
        race=night_elf\n";

    fn test_parameters() -> RunParameters {
        RunParameters::new(
            IterationCount::ONE,
            FightDurationSeconds::from_nonzero_const(30),
        )
    }

    fn test_runtime() -> Result<tokio::runtime::Runtime> {
        tokio::runtime::Runtime::new().context("failed to create test runtime")
    }

    async fn profile_config_from_simc(
        config: &ComparisonConfig,
        rotation_id: &str,
        encounter_fixture: Option<EncounterFixture>,
        profile_text: &str,
        resolver: &DynDataResolver<'_>,
    ) -> Result<String> {
        let profile = parse_simc(profile_text).context("failed to parse test SimC profile")?;
        let profile = profile_intent_data(profile, resolver).await?;

        serialize_profile_config(config, rotation_id, encounter_fixture, profile)
    }

    #[gtest]
    fn canonical_action_names_use_dbc_spell_identity_for_hunter_actions() -> GtestResult<()> {
        verify_that!(
            canonical_action_name(SpecId::BeastMastery, AUTO_SHOT_SPELL_ID, "auto_attack"),
            eq("auto_shot")
        )?;
        verify_that!(
            canonical_action_name(SpecId::BeastMastery, COBRA_SHOT_SPELL_ID, "arcane_shot"),
            eq("cobra_shot")
        )?;

        verify_that!(
            canonical_action_name(SpecId::BeastMastery, 1, "declared_name"),
            eq("declared_name")
        )
    }

    #[gtest]
    fn canonical_action_names_match_feral_simc_attribution() -> GtestResult<()> {
        verify_that!(
            canonical_action_name(SpecId::Feral, CAT_MELEE_SPELL_ID, "auto_attack"),
            eq("cat_melee")
        )?;
        verify_that!(
            canonical_action_name(SpecId::Feral, FERAL_MOONFIRE_SPELL_ID, "moonfire"),
            eq("lunar_inspiration")
        )?;

        verify_that!(
            canonical_action_name(SpecId::Guardian, CAT_MELEE_SPELL_ID, "auto_attack"),
            eq("auto_attack")
        )
    }

    #[gtest]
    fn feral_aura_names_do_not_overwrite_canonical_action_attribution() -> GtestResult<()> {
        let names =
            build_spell_name_map(SpecId::Feral).expect("Feral content introspection should build");

        verify_that!(
            names.get(&FERAL_MOONFIRE_SPELL_ID),
            some(eq("lunar_inspiration"))
        )?;

        verify_that!(names.get(&CAT_MELEE_SPELL_ID), some(eq("cat_melee")))
    }

    #[gtest]
    fn assisted_rotation_adds_each_registered_item_use_once() -> GtestResult<()> {
        let mut rotation = serde_json::json!({
            "actions": [{"type": "call", "list": "main"}],
            "lists": {"main": []}
        });
        let equipment = [(GearSlot::Trinket1, 1), (GearSlot::Trinket2, 249_346)];

        add_registered_item_uses(&mut rotation, equipment).or_fail()?;
        add_registered_item_uses(&mut rotation, equipment).or_fail()?;

        let actions = rotation["actions"].as_array().or_fail()?;

        verify_that!(actions, len(eq(2)))?;
        verify_that!(actions[0]["type"].as_str(), some(eq("use_trinket")))?;
        verify_that!(actions[0]["slot"].as_u64(), some(eq(2)))?;

        verify_that!(
            actions[0]["condition"]["key"].as_str(),
            some(eq("trinket_2_use"))
        )
    }

    #[gtest]
    fn wowlab_profile_config_uses_canonical_target_for_level_90_profile() -> GtestResult<()> {
        let config = ComparisonConfig {
            spec: SpecId::Feral,
            parameters: test_parameters(),
            race: None,
            bugs: true,
            simc_debug: false,
        };
        let resolver = InMemoryResolver::new();
        let resolver_dyn = DynDataResolver::from_ref(&resolver);
        let runtime = test_runtime().or_fail()?;
        let profile = parse_simc(FERAL_TEST_PROFILE).or_fail()?;
        let profile = runtime
            .block_on(profile_intent_data(profile, resolver_dyn))
            .or_fail()?;

        verify_that!(profile.player_level, eq(90))?;
        verify_that!(profile.player_expansion_id, eq(11))?;

        let serialized = runtime
            .block_on(profile_config_from_simc(
                &config,
                "feral_druid_assisted",
                None,
                FERAL_TEST_PROFILE,
                resolver_dyn,
            ))
            .or_fail()?;
        let parsed = parse_sim_config(&serialized).or_fail()?;

        verify_that!(parsed.player_level, eq(90))?;
        verify_that!(
            parsed.player_expansion_id,
            eq(crate::intent::PLAYER_EXPANSION_ID)
        )?;
        verify_that!(
            parsed.encounter.enemies.as_slice(),
            elements_are![matches_pattern!(EnemyDefinition {
                level: eq(&crate::intent::CANONICAL_PATCHWERK_ENEMY_LEVEL),
                difficulty: eq(&DifficultyContext::Generic {
                    expansion_id: crate::intent::CANONICAL_PATCHWERK_EXPANSION_ID,
                }),
                ..
            })]
        )?;

        for key in ["duration_s", "enemy_count", "expansion_id", "level"] {
            verify_true!(!parsed.settings.contains_key(key))?;
        }

        Ok(())
    }

    #[gtest]
    fn numeric_simc_expansion_talents_reach_the_engine_intent() -> GtestResult<()> {
        let config = ComparisonConfig {
            spec: SpecId::Fire,
            parameters: test_parameters(),
            race: None,
            bugs: true,
            simc_debug: false,
        };
        let resolver = InMemoryResolver::new();
        let resolver_dyn = DynDataResolver::from_ref(&resolver);
        let serialized = test_runtime()
            .or_fail()?
            .block_on(profile_config_from_simc(
                &config,
                "fire_mage_assisted",
                None,
                "mage=\"Test\"\n\
                 spec=fire\n\
                 level=90\n\
                 race=orc\n\
                 omnium_talents=136822:1/136816:1/136817:1/136820:1/136814:1\n",
                resolver_dyn,
            ))
            .or_fail()?;
        let parsed = parse_sim_config(&serialized).or_fail()?;

        verify_that!(
            parsed.expansion_talents.get("omnium"),
            eq(Some(&vec![
                "136822:1".to_string(),
                "136816:1".to_string(),
                "136817:1".to_string(),
                "136820:1".to_string(),
                "136814:1".to_string(),
            ]))
        )?;

        Ok(())
    }

    #[gtest]
    fn named_enchants_resolve_by_alias_rank_and_equipped_item_masks() -> GtestResult<()> {
        let parsed = parse_simc(
            "death_knight=\"Test\"\n\
             level=90\n\
             finger1=first,id=193708,enchant=eyes_of_the_eagle_2\n\
             finger2=second,id=249919,enchant=enchant_ring__eyes_of_the_eagle_2\n\
             legs=third,id=249969,enchant=forest_hunters_armor_kit_2\n",
        )
        .or_fail()?;
        let resolver = InMemoryResolver::new()
            .with_item(ItemDataFlat {
                id: 193_708,
                class_id: 4,
                subclass_id: 0,
                inventory_type: 11,
                ..ItemDataFlat::default()
            })
            .with_item(ItemDataFlat {
                id: 249_919,
                class_id: 4,
                subclass_id: 0,
                inventory_type: 11,
                ..ItemDataFlat::default()
            })
            .with_item(ItemDataFlat {
                id: 249_969,
                class_id: 4,
                subclass_id: 3,
                inventory_type: 7,
                ..ItemDataFlat::default()
            })
            .with_permanent_enchant(PermanentEnchantFlat {
                enchant_id: 7967,
                rank: 2,
                item_class: 4,
                inventory_type_mask: 1 << 11,
                subclass_mask: 0x1f,
                tokenized_name: "enchant_ring__eyes_of_the_eagle".to_string(),
            })
            .with_permanent_enchant(PermanentEnchantFlat {
                enchant_id: 8159,
                rank: 2,
                item_class: 4,
                inventory_type_mask: 1 << 7,
                subclass_mask: 0x1e,
                tokenized_name: "forest_hunters_armor_kit".to_string(),
            });
        let resolver_dyn = DynDataResolver::from_ref(&resolver);
        let profile = test_runtime()
            .or_fail()?
            .block_on(profile_intent_data(parsed, resolver_dyn))
            .or_fail()?;

        verify_that!(
            profile
                .gear
                .iter()
                .filter_map(|entry| entry.enchant_id)
                .collect::<Vec<_>>(),
            elements_are![eq(&7967), eq(&7967), eq(&8159)]
        )
    }

    #[gtest]
    fn wowlab_profile_config_substitutes_each_exact_phase_eight_fixture() -> GtestResult<()> {
        let config = ComparisonConfig {
            spec: SpecId::Feral,
            parameters: test_parameters(),
            race: None,
            bugs: true,
            simc_debug: false,
        };

        for fixture in [
            EncounterFixture::TwoTargetPack,
            EncounterFixture::BossAddWave,
            EncounterFixture::TwoPullDungeon,
        ] {
            let resolver = InMemoryResolver::new();
            let resolver_dyn = DynDataResolver::from_ref(&resolver);
            let serialized = test_runtime()
                .or_fail()?
                .block_on(profile_config_from_simc(
                    &config,
                    "feral_druid_assisted",
                    Some(fixture),
                    FERAL_TEST_PROFILE,
                    resolver_dyn,
                ))
                .or_fail()?;
            let parsed = parse_sim_config(&serialized).or_fail()?;
            let definition = fixture.definition().or_fail()?;

            verify_that!(
                &parsed,
                matches_pattern!(SimConfigIntent {
                    encounter: eq(&definition),
                    player_level: eq(&90),
                    ..
                })
            )?;
            verify_that!(parsed.encounter.fixed_duration_s, eq(None))?;
            verify_that!(
                parsed.settings.get("race").and_then(toml::Value::as_str),
                eq(Some("Night Elf"))
            )?;
        }

        Ok(())
    }
}