wowlab_engine_combat/state/program/damage/

compile.rs

use super::*;

impl DamagePlan {
    // #t(fn: rust_large_fn_params) cold compilation borrows independent finalized definition families without an owning compatibility aggregate.
    // #t(fn: rust_max_fn_lines) one cold pass keeps identity assignment, scalar lowering, target lowering, and dense layout auditable together.
    // #t(fn: rust_cyclomatic_complexity) exhaustive cold compilation follows every reachable trigger and effect-local lowering branch.
    // #t(fn: rust_string_error) the private compiler supplies exact spell/effect context before the draft wraps it in EngineError.
    #[expect(
        clippy::too_many_arguments,
        reason = "cold plan compilation keeps independent finalized registries explicit"
    )]
    pub(crate) fn compile(
        config: &ProgramConfig,
        spells: &[SpellData],
        auras: &[AuraData],
        passive_driver_effects: &[PassiveDriverEffect],
        spell_effects: &[SpellEffectData],
        declared_spell_ids: &[u32],
        generated_identities: &[DamageActionId],
        reachable_spell_ids: &[u32],
        required_target_spell_ids: &[u32],
        effect_plan: &EffectPlan,
        driver_spell_modifiers: &[DriverSpellModifier],
        impact_effect_procs: &[crate::state::ImpactEffectProc],
        periodic_drivers: &[crate::state::PeriodicDriver],
        landed_impact_procs: &[LandedImpactProc],
        auto_attacks: &[crate::state::AutoAttackData],
        hook_flat_damage: &wowlab_types::sim::FastMap<u32, f64>,
        hook_scalars: &wowlab_types::sim::FastMap<u32, f64>,
    ) -> Result<Self, String> {
        let data = &config.game_data;
        let mut required_effects = Vec::new();

        required_effects.extend(spells.iter().filter_map(|spell| {
            (!matches!(spell.damage, crate::state::RuntimeDamageDef::None))
                .then_some(spell.damage_effect)
        }));
        required_effects.extend(spells.iter().flat_map(|spell| {
            [
                (spell.channel.tick_damage, spell.channel.tick_spell_id),
                (
                    spell.channel.tick_damage_alt,
                    spell.channel.tick_damage_alt_spell_id,
                ),
            ]
            .into_iter()
            .filter_map(|(damage, spell_id)| {
                (!matches!(damage, crate::state::RuntimeDamageDef::None) && spell_id != 0)
                    .then_some(crate::state::DamageEffectRef::new(spell_id, 1))
            })
        }));
        required_effects.extend(spell_effects.iter().filter_map(|effect| match effect {
            SpellEffectData::Damage { effect, .. } => Some(*effect),
            SpellEffectData::Heal { effect, .. } | SpellEffectData::Energize { effect, .. } => {
                *effect
            }
            _ => None,
        }));
        required_effects.extend(
            auto_attacks
                .iter()
                .map(|attack| crate::state::DamageEffectRef::new(attack.spell_id, 1)),
        );

        for aura in auras {
            if let Some(periodic) = aura.periodic
                && matches!(
                    periodic.effect,
                    crate::state::PeriodicKind::FlatDamage { .. }
                        | crate::state::PeriodicKind::RollingFlatDamage { .. }
                        | crate::state::PeriodicKind::DamageAp { .. }
                        | crate::state::PeriodicKind::RollingDamageAp { .. }
                        | crate::state::PeriodicKind::DamageSp { .. }
                        | crate::state::PeriodicKind::RollingDamageSp { .. }
                        | crate::state::PeriodicKind::MaxHealthDamage { .. }
                        | crate::state::PeriodicKind::Leech { .. }
                        | crate::state::PeriodicKind::ResidualDamage
                )
            {
                let spell_id = periodic.damage_spell_id_or(aura.aura_id);

                required_effects.push(
                    periodic
                        .effect_ref
                        .unwrap_or_else(|| crate::state::DamageEffectRef::new(spell_id, 1)),
                );
                required_effects.push(
                    periodic
                        .effect_ref
                        .unwrap_or_else(|| crate::state::DamageEffectRef::new(spell_id, 0)),
                );
            }

            for effect in aura.effects.iter().flatten() {
                if let Some((spell_id, effect_index)) = effect.dbc_source() {
                    required_effects
                        .push(crate::state::DamageEffectRef::new(spell_id, effect_index));
                }

                match effect {
                    crate::state::BuffEffect::AutoAttackReplacement(spell_id) => {
                        required_effects.push(crate::state::DamageEffectRef::new(*spell_id, 1));
                    }
                    crate::state::BuffEffect::DamageReplication(definition) => {
                        required_effects.push(definition.effect);
                    }
                    _ => {}
                }
            }
        }

        for driver in passive_driver_effects {
            if let Some((spell_id, effect_index)) = driver.effect.dbc_source() {
                required_effects.push(crate::state::DamageEffectRef::new(spell_id, effect_index));
            }

            match driver.effect {
                crate::state::BuffEffect::AutoAttackReplacement(spell_id) => {
                    required_effects.push(crate::state::DamageEffectRef::new(spell_id, 1));
                }
                crate::state::BuffEffect::DamageReplication(definition) => {
                    required_effects.push(definition.effect);
                }
                _ => {}
            }
        }

        let mut executable_damage_effects = spells
            .iter()
            .filter_map(|spell| {
                (!matches!(spell.damage, crate::state::RuntimeDamageDef::None))
                    .then_some(spell.damage_effect)
            })
            .chain(spells.iter().flat_map(|spell| {
                [
                    (spell.channel.tick_damage, spell.channel.tick_spell_id),
                    (
                        spell.channel.tick_damage_alt,
                        spell.channel.tick_damage_alt_spell_id,
                    ),
                ]
                .into_iter()
                .filter_map(|(damage, spell_id)| {
                    (!matches!(damage, crate::state::RuntimeDamageDef::None) && spell_id != 0)
                        .then_some(crate::state::DamageEffectRef::new(spell_id, 1))
                })
            }))
            .chain(spell_effects.iter().filter_map(|effect| match effect {
                SpellEffectData::Damage { effect, .. } => Some(*effect),
                _ => None,
            }))
            .chain(
                auto_attacks
                    .iter()
                    .map(|attack| crate::state::DamageEffectRef::new(attack.spell_id, 1)),
            )
            .chain(
                required_target_spell_ids
                    .iter()
                    .copied()
                    .map(|spell_id| crate::state::DamageEffectRef::new(spell_id, 1)),
            )
            .collect::<Vec<_>>();

        for aura in auras {
            if let Some(periodic) = aura.periodic
                && matches!(
                    periodic.effect,
                    crate::state::PeriodicKind::FlatDamage { .. }
                        | crate::state::PeriodicKind::RollingFlatDamage { .. }
                        | crate::state::PeriodicKind::DamageAp { .. }
                        | crate::state::PeriodicKind::RollingDamageAp { .. }
                        | crate::state::PeriodicKind::DamageSp { .. }
                        | crate::state::PeriodicKind::RollingDamageSp { .. }
                        | crate::state::PeriodicKind::MaxHealthDamage { .. }
                        | crate::state::PeriodicKind::Leech { .. }
                        | crate::state::PeriodicKind::ResidualDamage
                )
            {
                let spell_id = periodic.damage_spell_id_or(aura.aura_id);

                executable_damage_effects.push(
                    periodic
                        .effect_ref
                        .unwrap_or_else(|| crate::state::DamageEffectRef::new(spell_id, 1)),
                );
            }

            executable_damage_effects.extend(aura.effects.iter().flatten().filter_map(|effect| {
                match effect {
                    crate::state::BuffEffect::AutoAttackReplacement(spell_id) => {
                        Some(crate::state::DamageEffectRef::new(*spell_id, 1))
                    }
                    crate::state::BuffEffect::DamageReplication(definition) => {
                        Some(definition.effect)
                    }
                    _ => None,
                }
            }));
        }

        executable_damage_effects.extend(passive_driver_effects.iter().filter_map(|driver| {
            match driver.effect {
                crate::state::BuffEffect::AutoAttackReplacement(spell_id) => {
                    Some(crate::state::DamageEffectRef::new(spell_id, 1))
                }
                crate::state::BuffEffect::DamageReplication(definition) => Some(definition.effect),
                _ => None,
            }
        }));
        required_effects.extend(executable_damage_effects.iter().copied());

        let mut required_max_effect_indices = wowlab_types::sim::FastMap::default();

        for effect in required_effects {
            required_max_effect_indices
                .entry(effect.spell_id)
                .and_modify(|index: &mut u8| *index = (*index).max(effect.effect_index))
                .or_insert(effect.effect_index);
        }

        let required_max_effect_index = |spell: SpellIdx| {
            required_max_effect_indices
                .get(&spell.as_u32())
                .copied()
                .unwrap_or_default()
                .max(data.max_effect_index(spell))
                .max(1)
        };
        let mut spell_ids = Vec::new();

        for &spell_id in declared_spell_ids {
            let spell = SpellIdx::from_raw(spell_id);

            if spell_id != 0 && !spell_ids.contains(&spell) {
                spell_ids.push(spell);
            }
        }

        let declared_action_count = spell_ids.len();

        for spell in spells {
            let spell = SpellIdx::from_raw(spell.spell_id);

            if !spell_ids.contains(&spell) {
                spell_ids.push(spell);
            }
        }

        for aura in auras {
            let spell = SpellIdx::from_raw(aura.aura_id);

            if !spell_ids.contains(&spell) {
                spell_ids.push(spell);
            }
        }

        if config.mastery_spell.as_u32() != 0 && !spell_ids.contains(&config.mastery_spell) {
            spell_ids.push(config.mastery_spell);
        }

        let mut extra_spell_ids = reachable_spell_ids
            .iter()
            .copied()
            .filter(|spell_id| *spell_id != 0)
            .map(SpellIdx::from_raw)
            .collect::<Vec<_>>();

        extra_spell_ids.extend(spell_effects.iter().filter_map(|effect| match effect {
            SpellEffectData::Damage { effect, .. }
            | SpellEffectData::Heal {
                effect: Some(effect),
                ..
            }
            | SpellEffectData::Energize {
                effect: Some(effect),
                ..
            } => Some(SpellIdx::from_raw(effect.spell_id)),
            SpellEffectData::Delayed {
                profile_spell_id, ..
            } => Some(SpellIdx::from_raw(*profile_spell_id)),
            _ => None,
        }));
        extra_spell_ids.extend(
            required_target_spell_ids
                .iter()
                .copied()
                .map(SpellIdx::from_raw),
        );
        extra_spell_ids.extend(
            periodic_drivers
                .iter()
                .map(|driver| SpellIdx::from_raw(driver.driver_spell_id)),
        );
        extra_spell_ids.extend(
            impact_effect_procs
                .iter()
                .flat_map(|proc| [proc.driver_spell_id, proc.profile_spell_id])
                .filter(|spell_id| *spell_id != 0)
                .map(SpellIdx::from_raw),
        );
        extra_spell_ids.extend(
            auras
                .iter()
                .flat_map(|aura| aura.effects.iter().flatten())
                .filter_map(crate::state::BuffEffect::listed_spell_ids)
                .flatten()
                .copied()
                .map(SpellIdx::from_raw),
        );
        extra_spell_ids.extend(auras.iter().flat_map(|aura| {
            [aura.apply_profile_spell_id, aura.tick_profile_spell_id]
                .into_iter()
                .filter(|spell_id| *spell_id != 0)
                .map(SpellIdx::from_raw)
        }));
        extra_spell_ids.extend(
            passive_driver_effects
                .iter()
                .filter_map(|driver| driver.effect.listed_spell_ids())
                .flatten()
                .copied()
                .map(SpellIdx::from_raw),
        );
        extra_spell_ids.extend(
            driver_spell_modifiers
                .iter()
                .flat_map(|modifier| modifier.spells.iter().copied())
                .map(SpellIdx::from_raw),
        );
        extra_spell_ids.extend(
            auras
                .iter()
                .flat_map(|aura| aura.effects.iter().flatten())
                .filter_map(crate::state::BuffEffect::dbc_source)
                .map(|(spell_id, _)| SpellIdx::from_raw(spell_id)),
        );
        extra_spell_ids.extend(
            auras
                .iter()
                .flat_map(|aura| aura.effects.iter().flatten())
                .filter_map(|effect| match effect {
                    crate::state::BuffEffect::AutoAttackReplacement(spell_id) => {
                        Some(SpellIdx::from_raw(*spell_id))
                    }
                    _ => None,
                }),
        );
        extra_spell_ids.extend(
            passive_driver_effects
                .iter()
                .filter_map(|driver| driver.effect.dbc_source())
                .map(|(spell_id, _)| SpellIdx::from_raw(spell_id)),
        );
        extra_spell_ids.sort_unstable();
        extra_spell_ids.dedup();

        for spell in extra_spell_ids {
            if !spell_ids.contains(&spell) {
                spell_ids.push(spell);
            }
        }

        let mut cursor = 0;

        while cursor < spell_ids.len() {
            // BOUNDS: the loop condition validates the cursor before each indexed read.
            let coordinate_spell = spell_ids[cursor];
            let max_effect_index = required_max_effect_index(coordinate_spell);

            for effect_index in 0..=max_effect_index {
                let coordinate = EffectRef::new(coordinate_spell, effect_index);

                if let Ok(triggered) = wowlab_engine_domain::dbc::resolve_triggered_damage(
                    wowlab_engine_domain::dbc::EffectLookup::new(data, coordinate),
                ) && !spell_ids.contains(&triggered.spell_id)
                {
                    spell_ids.push(triggered.spell_id);
                }
            }

            cursor += 1;
        }

        let mut extra_spell_ids = spell_ids.split_off(declared_action_count);

        extra_spell_ids.sort_unstable();
        extra_spell_ids.dedup();
        extra_spell_ids.retain(|spell| !spell_ids.contains(spell));
        spell_ids.extend(extra_spell_ids);

        let mut actions = Vec::with_capacity(spell_ids.len());
        let mut effects = Vec::new();
        let mut next_effect_start = 0_u32;
        let action_effect_starts = spell_ids
            .iter()
            .map(|&spell| {
                let start = next_effect_start;

                next_effect_start += u32::from(required_max_effect_index(spell)) + 1;

                start
            })
            .collect::<Vec<_>>();
        let mut folded_passive_effects = Vec::with_capacity(spell_ids.len());
        let capabilities = effect_plan.global_capabilities();
        let reflection_capable =
            capabilities.intersects(EffectFamily::REFLECTION | EffectFamily::DEFLECTION);

        for (action_ordinal, &spell) in spell_ids.iter().enumerate() {
            let raw = spell.as_u32();
            let local = LocalDamageActionIdx::new(action_ordinal)?;
            let school = wowlab_engine_domain::dbc::damage_school(data, spell)
                .unwrap_or(wowlab_types::combat::DamageSchool::Physical);
            let spell_props = data.spell_props_for_damage_plan(spell);
            let attributes = data.spell_attributes(spell).unwrap_or_default();
            let effect_start = LocalDamageEffectIdx::new(effects.len())?;
            let max_effect_index = required_max_effect_index(spell);
            let has_attack_effect = (1..=max_effect_index).any(|effect_index| {
                wowlab_engine_domain::dbc::spell_effect_is(
                    data.effect_type(spell, effect_index),
                    wowlab_engine_domain::dbc::SpellEffectKind::Attack,
                )
            });
            let has_direct_damage = wowlab_engine_domain::dbc::damage_def(data, spell).is_some();
            let casting_disabled_exception = wowlab_engine_domain::dbc::spell_attribute_is(
                attributes,
                wowlab_engine_domain::dbc::SpellAttributeKind::RangedAbility,
            ) || wowlab_engine_domain::dbc::spell_attribute_is(
                attributes,
                wowlab_engine_domain::dbc::SpellAttributeKind::IgnoreCastingDisabled,
            ) || has_attack_effect;
            let registered = spells.iter().find(|definition| definition.spell_id == raw);
            let profile_aoe =
                registered.map_or_else(DamageProfileAoe::default, |definition| DamageProfileAoe {
                    is_aoe: definition.targeting.is_aoe,
                    split: definition.targeting.split,
                    chain_targeting: definition.targeting.chain_targeting,
                    chain_multiplier: definition.targeting.chain_multiplier,
                    base_mult: definition.targeting.aoe_base_mult,
                    reduced_targets: definition.targeting.aoe_reduced_targets,
                    full_targets: definition.targeting.aoe_full_targets,
                    max_targets: definition.targeting.aoe_max_targets,
                });

            actions.push(DamageActionPlan {
                spell,
                effect_start,
                effect_count: u16::from(max_effect_index) + 1,
                passive: data.passive_spell_modifiers(spell),
                proc_chance: data.proc_chance(spell).unwrap_or_default(),
                gcd_ms: data.gcd_ms(spell).unwrap_or_default(),
                aura_duration_ms: data.aura_duration_ms(spell).unwrap_or_default(),
                aura_tick_ms: data.aura_tick_ms(spell).unwrap_or_default(),
                duration_hasted: data.duration_hasted(spell).unwrap_or(false),
                hasted_ticks: data.hasted_ticks(spell).unwrap_or(false),
                secondary_gain: data.secondary_gain(spell).unwrap_or_default(),
                primary_resource_gain: registered
                    .map_or(0.0, |definition| definition.cost.resource_gain),
                hook_flat_damage: hook_flat_damage.get(&raw).copied(),
                hook_scalar: hook_scalars.get(&raw).copied(),
                profile_base_points: registered.map_or(0.0, |definition| definition.base_points),
                profile_aoe,
                registered_damage: registered.and_then(|definition| {
                    (!matches!(definition.damage, crate::state::RuntimeDamageDef::None))
                        .then_some((definition.base_points, definition.damage))
                }),
                school,
                school_mask: SpellSchoolMask::from(school),
                mechanic_mask: data.spell_mechanic_mask(spell),
                attributes: attributes.to_vec().into_boxed_slice(),
                labels: data.spell_labels(spell).to_vec().into_boxed_slice(),
                proc_policy: crate::ProcPolicy::from_attributes(attributes),
                primary_cost_entry: spell_props.primary_cost_entry,
                secondary_cost_entry: spell_props.secondary_cost_entry,
                has_attack_effect,
                has_direct_damage,
                guaranteed_crit: registered
                    .is_some_and(|definition| definition.damage_policy.guaranteed_crit),
                casting_disabled_exception,
                reflection_eligible: reflection_capable
                    && reflection_eligible(attributes, spell_props.defense_type),
                defense_type: spell_props.defense_type,
                hit_chance_flat: spell_props.hit_chance_flat,
                hit_chance_multiplier: spell_props.hit_chance_multiplier,
                target_resistance_flat: spell_props.target_resistance_flat,
                target_resistance_multiplier: spell_props.target_resistance_multiplier,
                treat_as_periodic: data.treat_as_periodic(spell).unwrap_or(false),
                mastery_affects_points: spell_props.mastery_affects_points,
                damage_attribute_flags: crate::systems::damage_flags_from_data(data, spell, false),
                chain_target_range: data.chain_target_range(spell).unwrap_or_default(),
                ignores_line_of_sight: data.ignores_line_of_sight(spell).unwrap_or(false),
            });

            for effect_index in 0..=max_effect_index {
                let coordinate = EffectRef::new(spell, effect_index);
                let aoe = data.aoe_properties(spell, effect_index);
                let mut affected_actions = vec![0_u64; spell_ids.len().div_ceil(AFFECT_WORD_BITS)];

                for (target_ordinal, target) in spell_ids.iter().copied().enumerate() {
                    if data.effect_affects_spell(spell, effect_index, target) {
                        // BOUNDS: the bitset is sized from this exact local action universe.
                        affected_actions[target_ordinal / AFFECT_WORD_BITS] |=
                            1_u64 << (target_ordinal % AFFECT_WORD_BITS);
                    }
                }

                let direct_damage = wowlab_engine_domain::dbc::damage_def(data, spell)
                    .filter(|damage| damage.effect_index == effect_index);
                let triggered_damage = direct_damage
                    .is_none()
                    .then(|| {
                        wowlab_engine_domain::dbc::resolve_triggered_damage(
                            wowlab_engine_domain::dbc::EffectLookup::new(data, coordinate),
                        )
                        .ok()
                    })
                    .flatten();
                let geometry = triggered_damage.map_or(coordinate, |triggered| {
                    EffectRef::new(triggered.spell_id, triggered.damage.effect_index)
                });
                let resolved_damage =
                    direct_damage.or_else(|| triggered_damage.map(|triggered| triggered.damage));
                let runtime_damage = resolved_damage.and_then(|damage| {
                    crate::builder::lower_resolved_damage(
                        damage,
                        wowlab_engine_domain::constants::OFF_HAND_DAMAGE_MULT,
                    )
                });
                let resolved_damage_base_points = resolved_damage.map_or(0.0, |damage| {
                    crate::state::resolved_damage_base_points(damage, 1.0)
                });

                let local_effect = LocalDamageEffectIdx::new(effects.len())?;
                let geometry_action = spell_ids
                    .iter()
                    .position(|candidate| *candidate == geometry.spell)
                    .ok_or_else(|| {
                        // #t(block: rust_alloc_in_loop) allocation retains the exact coordinate only on construction failure.
                        format!(
                            "resolved damage geometry {}:{} is absent from the finalized action universe",
                            geometry.spell.as_u32(),
                            geometry.effect_index
                        )
                    })?;
                // BOUNDS: geometry_action is a position in spell_ids and starts has identical length.
                let geometry_effect_start = action_effect_starts[geometry_action];
                let geometry_local =
                    LocalDamageEffectIdx(geometry_effect_start + u32::from(geometry.effect_index));
                let target = (|| {
                    let target_plan = compile_target_plan(TargetPlanInput {
                        spell_id: raw,
                        effect_index,
                        effect_type: aoe.effect_type,
                        target_a: aoe.implicit_target_a,
                        target_b: aoe.implicit_target_b,
                    })
                    .map_err(|error| {
                        // #t(rust_alloc_in_loop) allocation occurs only on construction failure and retains the exact effect coordinate.
                        format!("failed to compile target plan for spell {raw} effect {effect_index}: {error}")
                    })?;
                    let is_multi_target =
                        wowlab_engine_domain::targeting::target_plan_is_multi_target(&target_plan);
                    let executable = lower_target_plan(&target_plan).map_err(|error| {
                        // #t(rust_alloc_in_loop) allocation occurs only on construction failure and retains the exact effect coordinate.
                        format!(
                            "failed to lower target plan for spell {raw} effect {effect_index}: {error}"
                        )
                    })?;
                    let overlay = registered_target_geometry_overlay(raw, effect_index).map_err(
                        |error| {
                            // #t(rust_alloc_in_loop) allocation occurs only on construction failure and retains the exact effect coordinate.
                            format!("failed to resolve target geometry for spell {raw} effect {effect_index}: {error}")
                        },
                    )?;
                    let data_radius = if aoe.radius > 0.0 {
                        aoe.radius
                    } else {
                        data.radius(spell).unwrap_or_default()
                    };

                    Ok::<_, String>(FinalizedTargetExecution {
                        executable,
                        is_multi_target,
                        radius: overlay.and_then(|value| value.radius).unwrap_or(data_radius),
                        range: overlay
                            .and_then(|value| value.range)
                            .unwrap_or_else(|| {
                                data.hostile_max_range(spell).unwrap_or(data_radius)
                            }),
                        cone_half_angle: overlay
                            .and_then(|value| value.cone_half_angle)
                            .unwrap_or_else(|| data.cone_half_angle(spell).unwrap_or_default()),
                        face_explicit_target: overlay
                            .is_some_and(|value| value.face_explicit_target)
                            || data.spell_attributes(spell).is_some_and(|attributes| {
                                wowlab_engine_domain::dbc::spell_attribute_is(
                                    attributes,
                                    wowlab_engine_domain::dbc::SpellAttributeKind::EnforceFacingPrimaryTargetOnly,
                                )
                            }),
                    })
                })();
                let target_required = executable_damage_effects
                    .iter()
                    .any(|effect| effect.spell_id == raw && effect.effect_index == effect_index)
                    || [
                        wowlab_engine_domain::dbc::SpellEffectKind::SchoolDamage,
                        wowlab_engine_domain::dbc::SpellEffectKind::HealthLeech,
                        wowlab_engine_domain::dbc::SpellEffectKind::WeaponDamageNoSchool,
                        wowlab_engine_domain::dbc::SpellEffectKind::WeaponPercentDamage,
                        wowlab_engine_domain::dbc::SpellEffectKind::WeaponDamage,
                        wowlab_engine_domain::dbc::SpellEffectKind::NormalizedWeaponDamage,
                    ]
                    .iter()
                    .any(|kind| *kind as i32 == aoe.effect_type);
                let target = match target {
                    Ok(target) => Some(target),
                    Err(error) if target_required => return Err(error),
                    Err(_) => None,
                };

                effects.push(DamageEffectPlan {
                    action: local,
                    effect_index,
                    aoe,
                    target,
                    mechanic_mask: data.effect_mechanic_mask(spell, effect_index),
                    base_points: data.base_points(spell, effect_index),
                    ap_coefficient: data.ap_coef(spell, effect_index),
                    sp_coefficient: data.sp_coef(spell, effect_index),
                    amplitude: data.amplitude(spell, effect_index),
                    period: data.period(spell, effect_index),
                    power_coefficient_mastery_add: data
                        .power_coefficient_mastery_add(spell, effect_index),
                    aura_subtype: data.effect_aura(spell, effect_index),
                    modifier_property: data.effect_misc_value_0(spell, effect_index),
                    attributes: data.effect_attributes(spell, effect_index),
                    geometry,
                    geometry_local,
                    resolved_damage: runtime_damage,
                    resolved_damage_base_points,
                    affected_actions: affected_actions.into_boxed_slice(),
                });

                if data.is_folded_passive(spell) {
                    folded_passive_effects.push(local_effect);
                }
            }
        }

        let mut generated_action_bindings = wowlab_types::sim::FastMap::default();
        let mut missing_generated_identity = None;

        for identity in generated_identities.iter().copied() {
            let Some(ordinal) = spell_ids
                .iter()
                .position(|spell| spell.as_u32() == identity.spell_id())
            else {
                missing_generated_identity = Some(identity);
                break;
            };

            generated_action_bindings.insert(identity, LocalDamageActionIdx::new(ordinal)?);
        }

        if let Some(identity) = missing_generated_identity {
            return Err(format!(
                "generated damage identity is absent from finalized action universe: {}",
                identity.spell_id()
            ));
        }

        let has_replication = capabilities.contains(EffectFamily::DAMAGE_REPLICATION);
        let power_type_id = |resource: Option<wowlab_types::combat::ResourceType>| {
            resource.map(|resource| i32::from(u8::from(resource)))
        };
        let primary_power_type = power_type_id(config.base_stats.resource_type);
        let secondary_power_type = power_type_id(config.base_stats.secondary_resource_type);
        let power_display_divisor = |power_type: Option<i32>| {
            power_type.map_or(1.0, |power_type| data.power_display_divisor(power_type))
        };
        let power_cost_percent = |power_type: Option<i32>| {
            power_type.map_or(0.0, |power_type| data.power_cost_percent(power_type))
        };

        let resolve_request = |effect: crate::state::DamageEffectRef,
                               geometry_effect: crate::state::DamageEffectRef,
                               profile_spell_id: u32|
         -> Result<DamageRequestBinding, String> {
            let finalize_action = |spell_id: u32| {
                spell_ids
                    .iter()
                    .position(|spell| spell.as_u32() == spell_id)
                    .ok_or_else(|| format!("unresolved finalized damage action {spell_id}"))
                    .and_then(LocalDamageActionIdx::new)
            };
            let bind_effect = |effect: crate::state::DamageEffectRef| {
                let action = finalize_action(effect.spell_id)?;
                // BOUNDS: finalize_action constructs indices only from positions in actions' source registry.
                let plan = &actions[action.index()];

                if u16::from(effect.effect_index) >= plan.effect_count {
                    return Err(format!(
                        "unresolved finalized damage effect {}:{}",
                        effect.spell_id, effect.effect_index
                    ));
                }

                Ok(LocalDamageEffectIdx(
                    plan.effect_start.0 + u32::from(effect.effect_index),
                ))
            };
            let effect = bind_effect(effect)?;
            let geometry_effect = bind_effect(geometry_effect)?;
            // BOUNDS: bind_effect validates coordinates against the dense effects ranges.
            let target = effects[geometry_effect.index()].target.ok_or_else(|| {
                format!(
                    "damage effect {}:{} has no finalized target execution",
                    // BOUNDS: every effect plan stores an action assigned from the actions registry.
                    actions[effects[geometry_effect.index()].action.index()]
                        .spell
                        .as_u32(),
                    effects[geometry_effect.index()].effect_index
                )
            })?;

            Ok(DamageRequestBinding {
                effect,
                // BOUNDS: bind_effect validated effect against the dense effects ranges.
                effect_action: effects[effect.index()].action,
                geometry_effect,
                profile_action: finalize_action(profile_spell_id)?,
                target,
            })
        };
        let spell_requests = spells
            .iter()
            .map(|spell| {
                (!matches!(spell.damage, crate::state::RuntimeDamageDef::None))
                    .then(|| {
                        resolve_request(spell.damage_effect, spell.damage_effect, spell.spell_id)
                            .map(|request| SpellDamageBinding { request })
                    })
                    .transpose()
            })
            .collect::<Result<Vec<_>, _>>()?;
        let spell_actions = spells
            .iter()
            .map(|spell| {
                spell_ids
                    .iter()
                    .position(|candidate| candidate.as_u32() == spell.spell_id)
                    .ok_or_else(|| format!("unresolved finalized spell action {}", spell.spell_id))
                    .and_then(LocalDamageActionIdx::new)
            })
            .collect::<Result<Vec<_>, _>>()?;
        let periodic_requests = auras
            .iter()
            .map(|aura| {
                let Some(periodic) = aura.periodic else {
                    return Ok(None);
                };
                let deals_damage = matches!(
                    periodic.effect,
                    crate::state::PeriodicKind::FlatDamage { .. }
                        | crate::state::PeriodicKind::RollingFlatDamage { .. }
                        | crate::state::PeriodicKind::DamageAp { .. }
                        | crate::state::PeriodicKind::RollingDamageAp { .. }
                        | crate::state::PeriodicKind::DamageSp { .. }
                        | crate::state::PeriodicKind::RollingDamageSp { .. }
                        | crate::state::PeriodicKind::MaxHealthDamage { .. }
                        | crate::state::PeriodicKind::Leech { .. }
                        | crate::state::PeriodicKind::ResidualDamage
                );

                if !deals_damage {
                    return Ok(None);
                }

                let spell_id = periodic.damage_spell_id_or(aura.aura_id);
                let effect = periodic
                    .effect_ref
                    .unwrap_or_else(|| crate::state::DamageEffectRef::new(spell_id, 1));

                let request = resolve_request(effect, effect, spell_id)?;
                let snapshot_coordinate = periodic
                    .effect_ref
                    .unwrap_or_else(|| crate::state::DamageEffectRef::new(spell_id, 0));
                let snapshot_action = spell_ids
                    .iter()
                    .position(|spell| spell.as_u32() == snapshot_coordinate.spell_id)
                    .ok_or_else(|| {
                        format!(
                            "unresolved periodic snapshot action {}",
                            snapshot_coordinate.spell_id
                        )
                    })
                    .and_then(LocalDamageActionIdx::new)?;
                // BOUNDS: the action index is constructed from a position in the actions source registry.
                let action = &actions[snapshot_action.index()];

                if u16::from(snapshot_coordinate.effect_index) >= action.effect_count {
                    return Err(format!(
                        "unresolved periodic snapshot effect {}:{}",
                        snapshot_coordinate.spell_id, snapshot_coordinate.effect_index
                    ));
                }

                let snapshot_effect = LocalDamageEffectIdx(
                    action.effect_start.0 + u32::from(snapshot_coordinate.effect_index),
                );

                Ok(Some(PeriodicDamageBinding {
                    request,
                    snapshot_effect,
                }))
            })
            .collect::<Result<Vec<_>, _>>()?;
        let aura_actions = auras
            .iter()
            .map(|aura| {
                spell_ids
                    .iter()
                    .position(|candidate| candidate.as_u32() == aura.aura_id)
                    .ok_or_else(|| format!("unresolved finalized aura action {}", aura.aura_id))
                    .and_then(LocalDamageActionIdx::new)
            })
            .collect::<Result<Vec<_>, _>>()?;
        let aura_profile_action = |aura: &AuraData, profile_spell_id: u32| {
            let profile_spell_id = if profile_spell_id == 0 {
                aura.aura_id
            } else {
                profile_spell_id
            };

            spell_ids
                .iter()
                .position(|candidate| candidate.as_u32() == profile_spell_id)
                .ok_or_else(|| {
                    format!("unresolved finalized aura profile action {profile_spell_id}")
                })
                .and_then(LocalDamageActionIdx::new)
        };
        let aura_apply_profile_actions = auras
            .iter()
            .map(|aura| aura_profile_action(aura, aura.apply_profile_spell_id))
            .collect::<Result<Vec<_>, _>>()?;
        let aura_tick_profile_actions = auras
            .iter()
            .map(|aura| aura_profile_action(aura, aura.tick_profile_spell_id))
            .collect::<Result<Vec<_>, _>>()?;
        let effect_requests = spell_effects
            .iter()
            .map(|effect| match effect {
                SpellEffectData::Damage { effect, .. } => {
                    resolve_request(*effect, *effect, effect.spell_id).map(Some)
                }
                _ => Ok(None),
            })
            .collect::<Result<Vec<_>, _>>()?;
        let spell_effect_sources = spell_effects
            .iter()
            .map(|effect| {
                let coordinate = match effect {
                    SpellEffectData::Damage { effect, .. } => Some(*effect),
                    SpellEffectData::Heal { effect, .. }
                    | SpellEffectData::Energize { effect, .. } => *effect,
                    _ => None,
                };

                coordinate
                    .map(|coordinate| {
                        let action = spell_ids
                            .iter()
                            .position(|spell| spell.as_u32() == coordinate.spell_id)
                            .ok_or_else(|| {
                                format!(
                                    "unresolved spell-effect source action {}",
                                    coordinate.spell_id
                                )
                            })
                            .and_then(LocalDamageActionIdx::new)?;
                        // BOUNDS: the action index is constructed from a position in the actions source registry.
                        let plan = &actions[action.index()];

                        if u16::from(coordinate.effect_index) >= plan.effect_count {
                            return Err(format!(
                                "unresolved spell-effect source {}:{}",
                                coordinate.spell_id, coordinate.effect_index
                            ));
                        }

                        Ok::<_, String>(LocalDamageEffectIdx(
                            plan.effect_start.0 + u32::from(coordinate.effect_index),
                        ))
                    })
                    .transpose()
            })
            .collect::<Result<Vec<_>, _>>()?;
        let delayed_profile_actions = spell_effects
            .iter()
            .map(|effect| match effect {
                SpellEffectData::Delayed {
                    profile_spell_id, ..
                } => spell_ids
                    .iter()
                    .position(|spell| spell.as_u32() == *profile_spell_id)
                    .ok_or_else(|| {
                        format!("unresolved delayed effect profile action {profile_spell_id}")
                    })
                    .and_then(LocalDamageActionIdx::new)
                    .map(Some),
                _ => Ok(None),
            })
            .collect::<Result<Vec<_>, _>>()?;
        let mastery_action = (config.mastery_spell.as_u32() != 0)
            .then(|| {
                spell_ids
                    .iter()
                    .position(|spell| *spell == config.mastery_spell)
                    .ok_or_else(|| {
                        format!(
                            "unresolved finalized mastery action {}",
                            config.mastery_spell.as_u32()
                        )
                    })
                    .and_then(LocalDamageActionIdx::new)
            })
            .transpose()?;
        let auto_attack_requests = auto_attacks
            .iter()
            .map(|attack| {
                let effect = crate::state::DamageEffectRef::new(attack.spell_id, 1);

                resolve_request(effect, effect, attack.spell_id)
            })
            .collect::<Result<Vec<_>, _>>()?;
        let main_hand = data.main_hand();
        let off_hand = data.off_hand();
        let dual_wield = off_hand.is_some();
        let mut player_auto_attack_index = 0_usize;
        let auto_attack_profiles = auto_attacks
            .iter()
            .zip(auto_attack_requests.iter().copied())
            .map(|(attack, request)| {
                let assigned_player_index = (!attack.is_pet).then(|| {
                    let index = player_auto_attack_index;

                    player_auto_attack_index = player_auto_attack_index.saturating_add(1);

                    index
                });
                let (weapon, hand) = match assigned_player_index {
                    Some(0) => (Some(main_hand), crate::state::SwingHand::MainHand),
                    Some(1) => (off_hand, crate::state::SwingHand::OffHand),
                    None | Some(_) => (None, crate::state::SwingHand::MainHand),
                };
                // BOUNDS: every request action was constructed from this finalized action array.
                let action = &actions[request.effect_action().index()];
                let resolved_damage = action.registered_damage.or_else(|| {
                    (0..action.effect_count).find_map(|offset| {
                        // BOUNDS: effect_start and effect_count were assigned from this finalized effect array.
                        let effect = &effects[action.effect_start.index() + usize::from(offset)];

                        effect
                            .resolved_damage
                            .map(|damage| (effect.resolved_damage_base_points, damage))
                    })
                });
                let weapon_payload = resolved_damage.and_then(|(_, damage)| match damage {
                    crate::state::RuntimeDamageDef::Weapon {
                        multiplier,
                        normalized,
                        is_physical,
                        ..
                    } => Some((multiplier, normalized, is_physical)),
                    _ => None,
                });
                let stat_inheritance =
                    attack
                        .npc_id
                        .map_or(crate::state::PetStatInheritance::IDENTITY, |npc_id| {
                            crate::state::PetStatInheritance::new(
                                data.pet_attack_power_inheritance_mult(npc_id),
                                data.pet_spell_power_inheritance_mult(npc_id),
                            )
                        });

                FinalizedAutoAttackProfile {
                    request,
                    weapon,
                    hand,
                    dual_wield,
                    weapon_multiplier: weapon_payload.map_or(1.0, |payload| payload.0),
                    normalized: weapon_payload.is_some_and(|payload| payload.1),
                    is_physical: weapon_payload.map_or(attack.is_physical, |payload| payload.2),
                    stat_inheritance,
                }
            })
            .collect::<Vec<_>>();
        let channel_requests = spells
            .iter()
            .map(|spell| {
                let bind = |damage: crate::state::RuntimeDamageDef, damage_spell_id: u32| {
                    if matches!(damage, crate::state::RuntimeDamageDef::None) {
                        return Ok(None);
                    }

                    let effect = crate::state::DamageEffectRef::new(damage_spell_id, 1);

                    resolve_request(effect, effect, spell.spell_id).map(Some)
                };

                Ok::<_, String>([
                    bind(spell.channel.tick_damage, spell.channel.tick_spell_id)?,
                    bind(
                        spell.channel.tick_damage_alt,
                        spell.channel.tick_damage_alt_spell_id,
                    )?,
                ])
            })
            .collect::<Result<Vec<_>, _>>()?;
        let mut replications = Vec::new();
        let mut compile_replication = |definition: crate::state::DamageReplication| {
            let request = resolve_request(
                definition.effect,
                definition.effect,
                definition.effect.spell_id,
            )?;
            let mut source_actions = vec![0_u64; actions.len().div_ceil(AFFECT_WORD_BITS)];

            if definition.source_spells.is_empty() {
                source_actions.fill(u64::MAX);
            } else {
                for &spell_id in definition.source_spells {
                    let action = spell_ids
                        .iter()
                        .position(|spell| spell.as_u32() == spell_id)
                        .ok_or_else(|| {
                            // #t(block: rust_alloc_in_loop) allocation retains the unresolved identity only on construction failure.
                            format!("unresolved replication source damage action {spell_id}")
                        })
                        .and_then(LocalDamageActionIdx::new)?;

                    // BOUNDS: source_actions is sized for every finalized action bit.

                    source_actions[action.index() / AFFECT_WORD_BITS] |=
                        1_u64 << (action.index() % AFFECT_WORD_BITS);
                }
            }

            let index = u16::try_from(replications.len())
                .map_err(|error| format!("replication plan exceeds u16 capacity: {error}"))?;

            replications.push(FinalizedDamageReplication {
                definition,
                request,
                source_actions: source_actions.into_boxed_slice(),
            });

            Ok::<_, String>(index)
        };
        let aura_replications = auras
            .iter()
            .map(|aura| {
                let mut bindings = [None; crate::state::MAX_AURA_BUFF_EFFECTS];

                for (position, effect) in aura.effects.iter().enumerate() {
                    if let Some(crate::state::BuffEffect::DamageReplication(definition)) = effect {
                        // BOUNDS: aura effect iteration is bounded by MAX_AURA_BUFF_EFFECTS.
                        bindings[position] = Some(compile_replication(*definition)?);
                    }
                }

                Ok::<_, String>(bindings)
            })
            .collect::<Result<Vec<_>, _>>()?;
        let passive_replications = passive_driver_effects
            .iter()
            .map(|driver| match driver.effect {
                crate::state::BuffEffect::DamageReplication(definition) => {
                    compile_replication(definition).map(Some)
                }
                _ => Ok(None),
            })
            .collect::<Result<Vec<_>, _>>()?;
        let compile_buff_binding = |effect: &crate::state::BuffEffect| {
            let finalize_action = |spell_id: u32| {
                spell_ids
                    .iter()
                    .position(|spell| spell.as_u32() == spell_id)
                    .ok_or_else(|| format!("unresolved finalized modifier action {spell_id}"))
                    .and_then(LocalDamageActionIdx::new)
            };
            let bind_effect = |spell_id: u32, effect_index: u8| {
                let action = finalize_action(spell_id)?;
                // BOUNDS: finalize_action constructs indices only from positions in actions' source registry.
                let plan = &actions[action.index()];

                if u16::from(effect_index) >= plan.effect_count {
                    return Err(format!(
                        "unresolved finalized modifier effect {spell_id}:{effect_index}"
                    ));
                }

                Ok(LocalDamageEffectIdx(
                    plan.effect_start.0 + u32::from(effect_index),
                ))
            };
            let source_effect = effect
                .dbc_source()
                .map(|(spell_id, effect_index)| bind_effect(spell_id, effect_index))
                .transpose()?;
            let replacement_request = match effect {
                crate::state::BuffEffect::AutoAttackReplacement(spell_id) => {
                    let coordinate = crate::state::DamageEffectRef::new(*spell_id, 1);

                    Some(resolve_request(coordinate, coordinate, *spell_id)?)
                }
                _ => None,
            };
            let mut listed_actions = vec![0_u64; actions.len().div_ceil(AFFECT_WORD_BITS)];

            if let Some(spells) = effect.listed_spell_ids() {
                for &spell_id in spells {
                    let action = finalize_action(spell_id)?;

                    // BOUNDS: listed_actions is sized for every finalized action bit.

                    listed_actions[action.index() / AFFECT_WORD_BITS] |=
                        1_u64 << (action.index() % AFFECT_WORD_BITS);
                }
            }

            Ok::<_, String>(FinalizedBuffDamageBinding {
                source_effect,
                replacement_request,
                listed_actions: listed_actions.into_boxed_slice(),
            })
        };
        let aura_buff_bindings = auras
            .iter()
            .map(|aura| {
                let mut bindings = std::array::from_fn(|_| None);

                for (position, effect) in aura.effects.iter().enumerate() {
                    if let Some(effect) = effect {
                        // BOUNDS: aura effect iteration is bounded by MAX_AURA_BUFF_EFFECTS.
                        bindings[position] = Some(compile_buff_binding(effect)?);
                    }
                }

                Ok::<_, String>(bindings)
            })
            .collect::<Result<Vec<_>, _>>()?;
        let passive_buff_bindings = passive_driver_effects
            .iter()
            .map(|driver| compile_buff_binding(&driver.effect).map(Some))
            .collect::<Result<Vec<_>, _>>()?;
        let driver_modifier_actions = driver_spell_modifiers
            .iter()
            .map(|modifier| {
                let mut actions_set = vec![0_u64; actions.len().div_ceil(AFFECT_WORD_BITS)];

                for &spell_id in modifier.spells {
                    let action = spell_ids
                        .iter()
                        .position(|spell| spell.as_u32() == spell_id)
                        .ok_or_else(|| {
                            // #t(block: rust_alloc_in_loop) allocation retains the unresolved identity only on construction failure.
                            format!("unresolved finalized driver modifier action {spell_id}")
                        })?;

                    // BOUNDS: actions_set is sized for every finalized action bit.

                    actions_set[action / AFFECT_WORD_BITS] |= 1_u64 << (action % AFFECT_WORD_BITS);
                }

                Ok::<_, String>(actions_set.into_boxed_slice())
            })
            .collect::<Result<Vec<_>, _>>()?;
        #[cfg(feature = "rotation-optimizations")]
        let driver_modifiers_by_action = {
            let mut by_action = vec![Vec::new(); actions.len()];

            for (modifier, listed_actions) in driver_modifier_actions.iter().enumerate() {
                for (action, modifiers) in by_action.iter_mut().enumerate() {
                    if listed_actions
                        .get(action / AFFECT_WORD_BITS)
                        .is_some_and(|word| word & (1_u64 << (action % AFFECT_WORD_BITS)) != 0)
                    {
                        modifiers.push(modifier);
                    }
                }
            }

            by_action
                .into_iter()
                .map(Vec::into_boxed_slice)
                .collect::<Vec<_>>()
                .into_boxed_slice()
        };
        #[cfg(feature = "rotation-optimizations")]
        let folded_passive_effects_by_action = {
            let mut by_action = vec![Vec::new(); actions.len()];

            for &effect in &folded_passive_effects {
                let effect_plan = finalized_effect_plan(&effects, effect);

                for (action, relevant) in by_action.iter_mut().enumerate() {
                    if effect_plan.affects_action(LocalDamageActionIdx::new(action)?) {
                        relevant.push(effect);
                    }
                }
            }

            by_action
                .into_iter()
                .map(Vec::into_boxed_slice)
                .collect::<Vec<_>>()
                .into_boxed_slice()
        };
        let impact_effect_driver_actions = impact_effect_procs
            .iter()
            .map(|proc| {
                (proc.driver_spell_id != 0)
                    .then(|| {
                        spell_ids
                            .iter()
                            .position(|spell| spell.as_u32() == proc.driver_spell_id)
                            .ok_or_else(|| {
                                format!(
                                    "unresolved finalized impact proc driver action {}",
                                    proc.driver_spell_id
                                )
                            })
                            .and_then(LocalDamageActionIdx::new)
                    })
                    .transpose()
            })
            .collect::<Result<Vec<_>, _>>()?;
        let impact_effect_profile_actions = impact_effect_procs
            .iter()
            .map(|proc| {
                let spell_id = if proc.profile_spell_id == 0 {
                    proc.driver_spell_id
                } else {
                    proc.profile_spell_id
                };

                (spell_id != 0)
                    .then(|| {
                        spell_ids
                            .iter()
                            .position(|spell| spell.as_u32() == spell_id)
                            .ok_or_else(|| {
                                format!(
                                    "unresolved finalized impact proc profile action {spell_id}"
                                )
                            })
                            .and_then(LocalDamageActionIdx::new)
                    })
                    .transpose()
            })
            .collect::<Result<Vec<_>, _>>()?;
        let periodic_driver_actions = periodic_drivers
            .iter()
            .map(|driver| {
                spell_ids
                    .iter()
                    .position(|spell| spell.as_u32() == driver.driver_spell_id)
                    .ok_or_else(|| {
                        format!(
                            "unresolved finalized periodic driver action {}",
                            driver.driver_spell_id
                        )
                    })
                    .and_then(LocalDamageActionIdx::new)
            })
            .collect::<Result<Vec<_>, _>>()?;

        Ok(Self {
            actions: actions.into_boxed_slice(),
            effects: effects.into_boxed_slice(),
            generated_action_bindings,
            #[cfg(not(feature = "rotation-optimizations"))]
            folded_passive_effects: folded_passive_effects.into_boxed_slice(),
            #[cfg(feature = "rotation-optimizations")]
            folded_passive_effects_by_action,
            crit_damage_per_crit_chance: data
                .crit_damage_per_crit_chance()
                .iter()
                .map(|(schools, percent)| (SpellSchoolMask::from_dbc(*schools), *percent))
                .collect(),
            spell_requests: spell_requests.into_boxed_slice(),
            spell_actions: spell_actions.into_boxed_slice(),
            periodic_requests: periodic_requests.into_boxed_slice(),
            aura_actions: aura_actions.into_boxed_slice(),
            aura_apply_profile_actions: aura_apply_profile_actions.into_boxed_slice(),
            aura_tick_profile_actions: aura_tick_profile_actions.into_boxed_slice(),
            effect_requests: effect_requests.into_boxed_slice(),
            spell_effect_sources: spell_effect_sources.into_boxed_slice(),
            delayed_profile_actions: delayed_profile_actions.into_boxed_slice(),
            mastery_action,
            auto_attacks: auto_attack_profiles.into_boxed_slice(),
            channel_requests: channel_requests.into_boxed_slice(),
            replications: replications.into_boxed_slice(),
            aura_replications: aura_replications.into_boxed_slice(),
            passive_replications: passive_replications.into_boxed_slice(),
            aura_buff_bindings: aura_buff_bindings.into_boxed_slice(),
            passive_buff_bindings: passive_buff_bindings.into_boxed_slice(),
            #[cfg(not(feature = "rotation-optimizations"))]
            driver_modifier_actions: driver_modifier_actions.into_boxed_slice(),
            #[cfg(feature = "rotation-optimizations")]
            driver_modifiers_by_action,
            impact_effect_driver_actions: impact_effect_driver_actions.into_boxed_slice(),
            impact_effect_profile_actions: impact_effect_profile_actions.into_boxed_slice(),
            periodic_driver_actions: periodic_driver_actions.into_boxed_slice(),
            auto_attack_damage_mult: data.auto_attack_damage_mult(),
            pet_damage_mult: data.pet_damage_mult(),
            guardian_damage_mult: data.guardian_damage_mult(),
            target_armor_mult: data.target_armor_mult(),
            player_level: i32::try_from(data.level()).unwrap_or(i32::MAX),
            main_hand: data.main_hand(),
            off_hand: data.off_hand(),
            primary_power_display_divisor: power_display_divisor(primary_power_type),
            secondary_power_display_divisor: power_display_divisor(secondary_power_type),
            primary_power_cost_percent: power_cost_percent(primary_power_type),
            secondary_power_cost_percent: power_cost_percent(secondary_power_type),
            rage_auto_attack_gain_multiplier: data.power_auto_attack_gain_multiplier(i32::from(
                u8::from(wowlab_types::combat::ResourceType::Rage),
            )),
            health_per_stamina: data.health_per_stamina(data.level()),
            has_spell_modifiers: capabilities.contains(EffectFamily::SPELL_MODIFIER)
                || !driver_spell_modifiers.is_empty(),
            has_armor_bypass: capabilities.contains(EffectFamily::ARMOR_BYPASS),
            has_health_critical: capabilities
                .contains(EffectFamily::HEALTH_DEPENDENT_CRITICAL_CHANCE),
            has_replication,
            has_reflection: capabilities.contains(EffectFamily::REFLECTION),
            has_deflection: capabilities.contains(EffectFamily::DEFLECTION),
            retains_landed_impacts: !landed_impact_procs.is_empty(),
        })
    }
}

#[cfg(feature = "rotation-optimizations")]
fn finalized_effect_plan(
    effects: &[DamageEffectPlan],
    effect: LocalDamageEffectIdx,
) -> &DamageEffectPlan {
    effects
        .get(effect.index())
        .expect("folded passive belongs to the finalized effect registry")
}