supreme_hook_config/

lib.rs

//! Shared data contract for the file-hooking modding system.
//!
//! This crate has no Windows-specific dependencies: it is compiled into
//! both the `launcher` (which writes a `HookConfig` out to disk) and the
//! `supreme_hook_proxy` DLL (which reads it back and applies it). Keeping
//! it platform-neutral means the redirection/patch logic can be unit
//! tested on any host, even though the DLL that consumes it only runs on
//! Windows.
//!
//! Module layout:
//! - [`error`], the shared [`HookConfigError`] type.
//! - [`mods_state`], plain load/save I/O for the mods directory's single
//!   state file (`mods.json`), and the `MOD_FILE_NAME` constant for
//!   each mod's own `mod.json`.
//! - [`mod_config`], [`ModConfig`], one mod's authored `mod.json`.
//! - [`ui`], the optional `ui` section of a `mod.json` ([`ModUi`]):
//!   launcher buttons/popups rendered generically by the Mods page.
//! - [`hook_config`], [`HookConfig`], the merged/resolved shape the proxy
//!   DLL consumes, and how a mods directory becomes one.
//! - [`dir_listing`], [`patch`], [`resolver`], [`script_engine`], see
//!   their own module docs.

pub mod dir_listing;
mod error;
pub mod hook_config;
pub mod mod_config;
pub mod mods_state;
pub mod patch;
pub mod resolver;
pub mod script_engine;
pub mod ui;
pub mod validation;

pub use dir_listing::{
    EntryOffsets, FilterResult, filter_redirected_entries, wildcard_match, write_directory_entry,
};
pub use error::HookConfigError;
pub use hook_config::{HookConfig, RedirectionMode, RedirectionRule, ResolvedAction, RuleTarget};
pub use mod_config::{ModConfig, ModParameter, ParameterKind};
pub use mods_state::{
    DEFAULT_MODS_DIR_NAME, MOD_FILE_NAME, MODS_STATE_FILE_NAME, ModConfigurations, ModsPreset,
    ModsState, load_mods_state, save_mods_state,
};
pub use patch::{BytesReplacement, MemoryPatch, ScriptSource, StringReplacement};
pub use resolver::{
    HookResolver, ManagedFileSpec, compute_target_path, is_write_operation, managed_file_specs,
    seed_target_file,
};
pub use ui::{ModUi, UiButton, UiField, UiFieldKind, UiPopup, UiPopupKind};
pub use validation::{PLAYER_NAME_TAG, ROOM_NAME_TAG, is_known_tag, validate_value};

// `MATCH_OPTIONS` isn't part of the crate's public API, it's an
// implementation detail of `hook_config`'s matching, but one test below
// exercises it directly against a raw `glob::Pattern`, so it's re-exported
// crate-internally rather than duplicated.
#[cfg(test)]
use hook_config::MATCH_OPTIONS;

#[cfg(test)]
mod tests {
    use std::{
        collections::HashMap,
        path::{Path, PathBuf},
    };

    use glob::Pattern;

    use super::*;

    fn sample_config() -> HookConfig {
        HookConfig {
            rules: vec![
                RedirectionRule {
                    glob_pattern: "data/levels/*.dat".into(),
                    target: Some(RuleTarget::Path(PathBuf::from("mods/custom_level"))),
                    mode: RedirectionMode::GracefulFallback,
                    patches: vec![],
                    enable_if: None,
                },
                RedirectionRule {
                    glob_pattern: "data/strings/*.txt".into(),
                    target: Some(RuleTarget::Path(PathBuf::from("mods/localization"))),
                    mode: RedirectionMode::HardError,
                    patches: vec![MemoryPatch::ReplaceString {
                        replacements: vec![StringReplacement {
                            find: "PLACEHOLDER".into(),
                            replace: "Bonjour".into(),
                            enable_if: None,
                        }],
                    }],
                    enable_if: None,
                },
            ],
        }
    }

    #[test]
    fn no_rule_matches_passes_through() {
        let config = sample_config();
        assert_eq!(
            config.resolve("data/audio/theme.ogg", |_| false),
            ResolvedAction::PassThrough
        );
    }

    #[test]
    fn matched_rule_with_existing_replacement_redirects() {
        let config = sample_config();
        let action = config.resolve("data/levels/level1.dat", |p| {
            p == Path::new("mods/custom_level/level1.dat")
        });
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from("mods/custom_level/level1.dat")
            }
        );
    }

    #[test]
    fn graceful_fallback_when_missing() {
        let config = sample_config();
        let action = config.resolve("data/levels/level1.dat", |_| false);
        assert_eq!(action, ResolvedAction::FallbackToOriginal);
    }

    #[test]
    fn hard_error_when_missing() {
        let config = sample_config();
        let action = config.resolve("data/strings/en.txt", |_| false);
        assert_eq!(action, ResolvedAction::HardErrorMissingFile);
    }

    #[test]
    fn hard_error_rule_still_redirects_when_present() {
        let config = sample_config();
        let action = config.resolve("data/strings/en.txt", |p| {
            p == Path::new("mods/localization/en.txt")
        });
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from("mods/localization/en.txt")
            }
        );
    }

    #[test]
    fn first_matching_rule_wins() {
        let mut config = sample_config();
        // Add a second, broader rule that would also match levels.
        config.rules.push(RedirectionRule {
            glob_pattern: "data/**".into(),
            target: Some(RuleTarget::Path(PathBuf::from("mods/catch_all"))),
            mode: RedirectionMode::GracefulFallback,
            patches: vec![],
            enable_if: None,
        });
        let action = config.resolve("data/levels/level1.dat", |p| {
            p == Path::new("mods/custom_level/level1.dat")
        });
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from("mods/custom_level/level1.dat")
            }
        );
    }

    #[test]
    fn roundtrip_through_json_file() {
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join("hook_config.json");
        let config = sample_config();
        config.write_to_path(&path).unwrap();
        let loaded = HookConfig::load_from_path(&path).unwrap();
        assert_eq!(config, loaded);
    }

    fn rule_with_pattern(glob_pattern: &str) -> HookConfig {
        HookConfig {
            rules: vec![RedirectionRule {
                glob_pattern: glob_pattern.into(),
                target: Some(RuleTarget::Path(PathBuf::from("mods/x"))),
                mode: RedirectionMode::GracefulFallback,
                patches: vec![],
                enable_if: None,
            }],
        }
    }

    #[test]
    fn single_star_does_not_cross_path_separators() {
        let config = rule_with_pattern("data/levels/*.dat");
        assert!(
            config
                .find_matching_rule("data/levels/level1.dat")
                .is_some()
        );
        assert!(
            config
                .find_matching_rule("data/levels/sub/level1.dat")
                .is_none()
        );
    }

    #[test]
    fn double_star_crosses_path_separators() {
        let config = rule_with_pattern("data/**/level1.dat");
        assert!(config.find_matching_rule("data/level1.dat").is_some());
        assert!(config.find_matching_rule("data/a/b/level1.dat").is_some());
    }

    #[test]
    fn matching_is_case_insensitive() {
        let config = rule_with_pattern("Data/Levels/*.DAT");
        assert!(
            config
                .find_matching_rule("data/levels/level1.dat")
                .is_some()
        );
    }

    #[test]
    fn invalid_glob_pattern_never_matches() {
        // A `**` that doesn't span a full path component is invalid glob
        // syntax; such a rule should simply never match rather than panic.
        let config = rule_with_pattern("data/levels/**.dat");
        assert!(
            config
                .find_matching_rule("data/levels/level1.dat")
                .is_none()
        );
    }

    fn directory_rule(glob_pattern: &str, target: &str) -> HookConfig {
        HookConfig {
            rules: vec![RedirectionRule {
                glob_pattern: glob_pattern.into(),
                target: Some(RuleTarget::Path(PathBuf::from(target))),
                mode: RedirectionMode::GracefulFallback,
                patches: vec![],
                enable_if: None,
            }],
        }
    }

    #[test]
    fn directory_tree_redirection_preserves_relative_structure() {
        // path/to/directory/** -> replacement/path/to/other/directory,
        // keeping everything below the matched prefix intact instead of
        // flattening it down to just the file's basename.
        let config = directory_rule(
            "path/to/directory/**",
            "replacement/path/to/other/directory",
        );
        let action = config.resolve("path/to/directory/sub/dir/asset.dds", |p| {
            p == Path::new("replacement/path/to/other/directory/sub/dir/asset.dds")
        });
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from(
                    "replacement/path/to/other/directory/sub/dir/asset.dds"
                )
            }
        );
    }

    #[test]
    fn directory_redirection_target_trailing_slash_is_irrelevant() {
        // A trailing slash on target shouldn't change the resulting path;
        // PathBuf::join handles both forms identically.
        let with_slash = directory_rule("path/to/directory/**", "replacement/dir/");
        let without_slash = directory_rule("path/to/directory/**", "replacement/dir");
        for config in [with_slash, without_slash] {
            let action = config.resolve("path/to/directory/asset.dds", |_| true);
            assert_eq!(
                action,
                ResolvedAction::Redirect {
                    replacement_path: PathBuf::from("replacement/dir/asset.dds")
                }
            );
        }
    }

    /// Regression test: rule authors write patterns in whatever case reads
    /// naturally (`Data/Levels/...`), while a `rel_key` built from a live NT
    /// path is always lowercased before it ever reaches this code. Matching
    /// (`find_matching_rule`) has always accounted for that, see
    /// `matching_is_case_insensitive`, but the subdirectory-preserving
    /// suffix computation used to do a plain byte-prefix check and silently
    /// fell back to just the file's basename on a case-only mismatch,
    /// dropping every directory level the pattern's fixed prefix covered.
    /// This is the exact rule/rel_key shape reported flattening
    /// `.../tracks/easy/replays/replay_0.dat` into `.../tracks/easy/replay_0.dat`.
    #[test]
    fn directory_tree_redirection_matches_case_insensitively() {
        let config = directory_rule(
            "Data/Levels/Alpine/Tracks/Easy/**",
            "D:/SupremeLight/Data/Levels/Practice/Tracks/Easy/",
        );
        let action = config.resolve("data/levels/alpine/tracks/easy/replays/replay_0.dat", |p| {
            p == Path::new("D:/SupremeLight/Data/Levels/Practice/Tracks/Easy/replays/replay_0.dat")
        });
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from(
                    "D:/SupremeLight/Data/Levels/Practice/Tracks/Easy/replays/replay_0.dat"
                )
            }
        );
    }

    #[test]
    fn flat_single_component_pattern_still_reduces_to_basename() {
        // No subdirectory portion below the wildcard here, so this should
        // behave exactly as it did before directory-tree support existed.
        let config = directory_rule("data/levels/*.dat", "mods/custom_level");
        let action = config.resolve("data/levels/level1.dat", |p| {
            p == Path::new("mods/custom_level/level1.dat")
        });
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from("mods/custom_level/level1.dat")
            }
        );
    }

    #[test]
    fn backslash_paths_are_normalized_and_match_properly() {
        let config = sample_config();
        // Test that "data\strings\en.txt" matches "data/strings/*.txt" and redirects correctly
        let action = config.resolve("data\\strings\\en.txt", |p| {
            p == Path::new("mods/localization/en.txt")
        });
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from("mods/localization/en.txt")
            }
        );
    }

    #[test]
    fn literal_glob_target_is_used_directly_not_joined() {
        // Regression test: a glob with no wildcard at all names exactly
        // one path, so `target` is the replacement file itself, nothing
        // should be joined onto it (the original bug joined the matched
        // file name onto `target`, turning a file path into a bogus
        // nested path like ".../Practice_..._high_times.txt/Alpine_..._high_times.txt").
        let config = HookConfig {
            rules: vec![RedirectionRule {
                glob_pattern: "Saved_Data/Alpine_Tracks_Easy_high_times.txt".into(),
                target: Some(RuleTarget::Path(PathBuf::from(
                    "Saved_Data/Practice_Tracks_Easy_high_times.txt",
                ))),
                mode: RedirectionMode::HardError,
                patches: vec![],
                enable_if: None,
            }],
        };
        let action = config.resolve("Saved_Data/Alpine_Tracks_Easy_high_times.txt", |p| {
            p == Path::new("Saved_Data/Practice_Tracks_Easy_high_times.txt")
        });
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from("Saved_Data/Practice_Tracks_Easy_high_times.txt")
            }
        );
    }

    #[test]
    fn is_literal_glob_detects_wildcards() {
        assert!(rule_with_pattern("data/levels/level1.dat").rules[0].is_literal_glob());
        assert!(!rule_with_pattern("data/levels/*.dat").rules[0].is_literal_glob());
        assert!(!rule_with_pattern("data/levels/**").rules[0].is_literal_glob());
        assert!(!rule_with_pattern("data/levels/level?.dat").rules[0].is_literal_glob());
    }

    #[test]
    fn omitted_target_falls_back_in_graceful_mode_without_probing_disk() {
        let config = HookConfig {
            rules: vec![RedirectionRule {
                glob_pattern: "data/levels/level1.dat".into(),
                target: None,
                mode: RedirectionMode::GracefulFallback,
                patches: vec![],
                enable_if: None,
            }],
        };
        // file_exists must never be called: there's no path to probe.
        let action = config.resolve("data/levels/level1.dat", |_| {
            panic!("file_exists should not be called when target is None")
        });
        assert_eq!(action, ResolvedAction::FallbackToOriginal);
    }

    #[test]
    fn omitted_target_hard_blocks_in_hard_error_mode() {
        let config = HookConfig {
            rules: vec![RedirectionRule {
                glob_pattern: "Saved_Data/high_times.txt".into(),
                target: None,
                mode: RedirectionMode::HardError,
                patches: vec![],
                enable_if: None,
            }],
        };
        let action = config.resolve("Saved_Data/high_times.txt", |_| {
            panic!("file_exists should not be called when target is None")
        });
        assert_eq!(action, ResolvedAction::HardErrorMissingFile);
    }

    #[test]
    fn target_field_is_omittable_in_json() {
        let json = r#"{"rules":[{"glob_pattern":"data/levels/*.dat","mode":"graceful_fallback"}]}"#;
        let config: HookConfig = serde_json::from_str(json).unwrap();
        assert_eq!(config.rules.len(), 1);
        assert_eq!(config.rules[0].target, None);
        assert!(config.rules[0].patches.is_empty());
    }

    // --- ModConfig / ModParameter -----------------------------------

    fn boolean_param(id: &str) -> ModParameter {
        ModParameter {
            id: id.to_string(),
            name: id.to_string(),
            help_text: String::new(),
            kind: ParameterKind::Boolean,
            enable_if: None,
            hidden: false,
            validation: None,
        }
    }

    fn dropdown_param(id: &str, choices: &[&str]) -> ModParameter {
        ModParameter {
            id: id.to_string(),
            name: id.to_string(),
            help_text: String::new(),
            kind: ParameterKind::Dropdown {
                choices: choices.iter().map(|s| (*s).to_string()).collect(),
            },
            enable_if: None,
            hidden: false,
            validation: None,
        }
    }

    fn number_param(id: &str, min: f32, max: f32) -> ModParameter {
        ModParameter {
            id: id.to_string(),
            name: id.to_string(),
            help_text: String::new(),
            kind: ParameterKind::Number {
                min,
                max,
                step: None,
            },
            enable_if: None,
            hidden: false,
            validation: None,
        }
    }

    fn text_param(id: &str) -> ModParameter {
        ModParameter {
            id: id.to_string(),
            name: id.to_string(),
            help_text: String::new(),
            kind: ParameterKind::Text,
            enable_if: None,
            hidden: false,
            validation: None,
        }
    }

    fn gated_rule(glob_pattern: &str, target: &str, enable_if: &str) -> RedirectionRule {
        RedirectionRule {
            glob_pattern: glob_pattern.into(),
            target: Some(RuleTarget::Path(PathBuf::from(target))),
            mode: RedirectionMode::GracefulFallback,
            patches: vec![],
            enable_if: Some(enable_if.to_string()),
        }
    }

    #[test]
    fn mod_json_round_trips_every_parameter_kind() {
        let config = ModConfig {
            name: "Custom Boards Pack".to_string(),
            author: Some("someone".to_string()),
            license: Some("MIT".to_string()),
            description: Some("Adds custom boards".to_string()),
            version: Some("1.0.0".to_string()),
            rules: vec![gated_rule(
                "Data/Boards/style.dat",
                ".supreme/mods/custom_boards/styles/${Board_Style}.dat",
                "Board_Style",
            )],
            parameters: vec![
                boolean_param("Transparent_Board"),
                dropdown_param("Board_Style", &["Wood", "Carbon", "Neon"]),
                number_param("Fov_Boost", 0.0, 20.0),
                text_param("Custom_Label"),
            ],
            // The author's own defaults, distinct from any per-user
            // override in the active preset's configuration.
            configuration: HashMap::from([
                ("Board_Style".to_string(), serde_json::json!("Wood")),
                ("Custom_Label".to_string(), serde_json::json!("Hello")),
            ]),
            ui: None,
        };

        let json = serde_json::to_string_pretty(&config).unwrap();
        let loaded: ModConfig = serde_json::from_str(&json).unwrap();
        assert_eq!(config, loaded);

        // Confirm the flat wire shape the launcher/mod authors actually
        // see, `type` alongside `id`/`name`/`help_text`, not nested.
        let value: serde_json::Value = serde_json::from_str(&json).unwrap();
        assert_eq!(value["parameters"][0]["type"], "boolean");
        assert_eq!(value["parameters"][1]["type"], "dropdown");
        assert_eq!(value["parameters"][1]["choices"][0], "Wood");
        assert_eq!(value["parameters"][2]["type"], "number");
        assert_eq!(value["parameters"][2]["min"], 0.0);
        assert_eq!(value["parameters"][3]["type"], "text");
        assert_eq!(value["configuration"]["Board_Style"], "Wood");
    }

    #[test]
    fn only_name_is_mandatory() {
        let json = r#"{"name":"Bare Mod"}"#;
        let config: ModConfig = serde_json::from_str(json).unwrap();
        assert_eq!(config.name, "Bare Mod");
        assert_eq!(config.author, None);
        assert!(config.rules.is_empty());
        assert!(config.parameters.is_empty());
        assert!(config.configuration.is_empty());
    }

    #[test]
    fn gating_reads_boolean_and_dropdown_truthiness() {
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![
                gated_rule("a", "target_a", "Enabled"),
                gated_rule("b", "target_b", "Board_Style != \"\""),
            ],
            parameters: vec![
                boolean_param("Enabled"),
                dropdown_param("Board_Style", &["Wood", "Carbon"]),
            ],
            ..ModConfig::default()
        };
        let mut configuration = HashMap::from([
            ("Enabled".to_string(), serde_json::json!(false)),
            ("Board_Style".to_string(), serde_json::json!("")),
        ]);
        // Both parameters currently "off": neither rule survives.
        assert!(config.resolved_rules(&configuration).is_empty());

        configuration.insert("Enabled".to_string(), serde_json::json!(true));
        configuration.insert("Board_Style".to_string(), serde_json::json!("Wood"));
        assert_eq!(config.resolved_rules(&configuration).len(), 2);
    }

    #[test]
    fn unset_parameter_reads_as_off() {
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![gated_rule("a", "target_a", "Never_Configured")],
            parameters: vec![boolean_param("Never_Configured")],
            ..ModConfig::default()
        };
        assert!(config.resolved_rules(&HashMap::new()).is_empty());
    }

    #[test]
    fn mod_json_configuration_supplies_defaults_when_no_override_exists() {
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![gated_rule("a", "target_a", "Enabled")],
            parameters: vec![boolean_param("Enabled")],
            // The author's own default, shipped in mod.json, not an
            // override from the active preset's configuration.
            configuration: HashMap::from([("Enabled".to_string(), serde_json::json!(true))]),
            author: None,
            license: None,
            description: None,
            version: None,
            ui: None,
        };

        // No overrides supplied at all: the rule is still on, from the
        // mod's own default alone.
        assert_eq!(config.resolved_rules(&HashMap::new()).len(), 1);
    }

    #[test]
    fn override_takes_precedence_over_mod_json_default() {
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![gated_rule("a", "target_a", "Enabled")],
            parameters: vec![boolean_param("Enabled")],
            configuration: HashMap::from([("Enabled".to_string(), serde_json::json!(true))]),
            author: None,
            license: None,
            description: None,
            version: None,
            ui: None,
        };
        let overrides = HashMap::from([("Enabled".to_string(), serde_json::json!(false))]);

        // A person explicitly turned it off, that overrides the author's
        // default of "on".
        assert!(config.resolved_rules(&overrides).is_empty());
    }

    #[test]
    fn effective_configuration_merges_defaults_with_overrides() {
        let config = ModConfig {
            name: "Test".to_string(),
            configuration: HashMap::from([
                ("A".to_string(), serde_json::json!("default_a")),
                ("B".to_string(), serde_json::json!("default_b")),
            ]),
            ..ModConfig::default()
        };
        let overrides = HashMap::from([("B".to_string(), serde_json::json!("override_b"))]);

        let effective = config.effective_configuration(&overrides);
        assert_eq!(effective.get("A"), Some(&serde_json::json!("default_a")));
        // B has both a default and an override, the override wins.
        assert_eq!(effective.get("B"), Some(&serde_json::json!("override_b")));
    }

    #[test]
    fn interpolation_fills_glob_pattern_target_and_patch_text() {
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![RedirectionRule {
                glob_pattern: "Data/${Board_Style}/*.dat".into(),
                target: Some(RuleTarget::Path(PathBuf::from("mods/${Board_Style}"))),
                mode: RedirectionMode::GracefulFallback,
                patches: vec![MemoryPatch::ReplaceString {
                    replacements: vec![StringReplacement {
                        find: "${Board_Style}_placeholder".into(),
                        replace: "Loaded ${Board_Style}".into(),
                        enable_if: None,
                    }],
                }],
                enable_if: None,
            }],
            parameters: vec![dropdown_param("Board_Style", &["Wood", "Carbon"])],
            ..ModConfig::default()
        };
        let configuration = HashMap::from([("Board_Style".to_string(), serde_json::json!("Wood"))]);

        let resolved = config.resolved_rules(&configuration);
        assert_eq!(resolved.len(), 1);
        assert_eq!(resolved[0].glob_pattern, "Data/Wood/*.dat");
        assert_eq!(
            resolved[0].target,
            Some(RuleTarget::Path(PathBuf::from("mods/Wood")))
        );
        let MemoryPatch::ReplaceString { replacements } = &resolved[0].patches[0] else {
            panic!("expected ReplaceString");
        };
        assert_eq!(replacements[0].find, "Wood_placeholder");
        assert_eq!(replacements[0].replace, "Loaded Wood");
    }

    #[test]
    fn one_parameter_can_gate_while_another_substitutes() {
        // `enable_if` and the placeholder used for interpolation don't
        // have to be the same parameter.
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![gated_rule(
                "Data/Boards/**",
                "mods/${Board_Style}",
                "Transparent_Board",
            )],
            parameters: vec![
                boolean_param("Transparent_Board"),
                dropdown_param("Board_Style", &["Wood", "Carbon"]),
            ],
            ..ModConfig::default()
        };
        let configuration = HashMap::from([
            ("Transparent_Board".to_string(), serde_json::json!(true)),
            ("Board_Style".to_string(), serde_json::json!("Carbon")),
        ]);
        let resolved = config.resolved_rules(&configuration);
        assert_eq!(resolved.len(), 1);
        assert_eq!(
            resolved[0].target,
            Some(RuleTarget::Path(PathBuf::from("mods/Carbon")))
        );
    }

    #[test]
    fn unknown_placeholder_is_left_unchanged() {
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![RedirectionRule {
                glob_pattern: "Data/${Nonexistent}/*.dat".into(),
                target: None,
                mode: RedirectionMode::GracefulFallback,
                patches: vec![],
                enable_if: None,
            }],
            ..ModConfig::default()
        };
        // `${Nonexistent}` references no declared parameter, so Rhai
        // interpolation fails and the original text is returned unchanged.
        assert_eq!(
            config.resolved_rules(&HashMap::new())[0].glob_pattern,
            "Data/${Nonexistent}/*.dat"
        );
    }

    #[test]
    fn unterminated_interpolation_is_left_literal() {
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![RedirectionRule {
                glob_pattern: "Data/${unterminated".into(),
                target: None,
                mode: RedirectionMode::GracefulFallback,
                patches: vec![],
                enable_if: None,
            }],
            ..ModConfig::default()
        };
        // A `${` with no closing `}` is malformed: Rhai interpolation
        // fails and the original text is returned unchanged.
        assert_eq!(
            config.resolved_rules(&HashMap::new())[0].glob_pattern,
            "Data/${unterminated"
        );
    }

    #[test]
    fn glob_special_characters_in_a_substituted_value_are_escaped() {
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![RedirectionRule {
                glob_pattern: "Data/${Label}.dat".into(),
                target: None,
                mode: RedirectionMode::GracefulFallback,
                patches: vec![],
                enable_if: None,
            }],
            parameters: vec![text_param("Label")],
            ..ModConfig::default()
        };
        let configuration =
            HashMap::from([("Label".to_string(), serde_json::json!("weird*name?[x]"))]);
        let resolved = config.resolved_rules(&configuration);
        assert_eq!(resolved[0].glob_pattern, "Data/weird[*]name[?][[]x[]].dat");
        // And it must still parse as a valid glob pattern that matches the
        // literal string it was built from, not a wildcard.
        let pattern = Pattern::new(&resolved[0].glob_pattern).unwrap();
        assert!(pattern.matches_with("Data/weird*name?[x].dat", MATCH_OPTIONS));
        assert!(!pattern.matches_with("Data/weirdXnameY.dat", MATCH_OPTIONS));
    }

    #[test]
    fn replace_bytes_patch_is_never_interpolated() {
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![RedirectionRule {
                glob_pattern: "a".into(),
                target: None,
                mode: RedirectionMode::GracefulFallback,
                patches: vec![MemoryPatch::ReplaceBytes {
                    replacements: vec![BytesReplacement {
                        find: b"${Label}".to_vec(),
                        replace: b"unchanged".to_vec(),
                        enable_if: None,
                    }],
                }],
                enable_if: None,
            }],
            parameters: vec![text_param("Label")],
            ..ModConfig::default()
        };
        let configuration =
            HashMap::from([("Label".to_string(), serde_json::json!("substituted"))]);
        let resolved = config.resolved_rules(&configuration);
        let MemoryPatch::ReplaceBytes { replacements } = &resolved[0].patches[0] else {
            panic!("expected ReplaceBytes");
        };
        assert_eq!(replacements[0].find, b"${Label}");
    }

    /// Modeled closely on the real "Fast count-down" mod that motivated
    /// per-replacement `enable_if`: one unconditional rule whose patch
    /// mixes replacements gated by a boolean (`Fast_Start`) with
    /// unconditional ones that only use `${param_id}` interpolation.
    fn fast_start_style_config() -> ModConfig {
        ModConfig {
            name: "Fast count-down".to_string(),
            rules: vec![RedirectionRule {
                glob_pattern: "Data/General/Object_Classes.txt".into(),
                target: None,
                mode: RedirectionMode::GracefulFallback,
                patches: vec![MemoryPatch::ReplaceString {
                    replacements: vec![
                        StringReplacement {
                            find: "player_start_time\t= 3;".into(),
                            replace: "player_start_time = 1;".into(),
                            enable_if: Some("Fast_Start".to_string()),
                        },
                        StringReplacement {
                            find: "go_end_time\t= 3;".into(),
                            replace: "go_end_time\t= 0.9;".into(),
                            enable_if: Some("Fast_Start".to_string()),
                        },
                        StringReplacement {
                            find: "GET READY".into(),
                            replace: "${First_Start_Text}".into(),
                            enable_if: None,
                        },
                        StringReplacement {
                            find: "GO!!!".into(),
                            replace: "${Second_Start_Text}".into(),
                            enable_if: None,
                        },
                    ],
                }],
                enable_if: None,
            }],
            parameters: vec![
                boolean_param("Fast_Start"),
                text_param("First_Start_Text"),
                text_param("Second_Start_Text"),
            ],
            configuration: HashMap::from([
                ("First_Start_Text".to_string(), serde_json::json!("Ready")),
                ("Second_Start_Text".to_string(), serde_json::json!("Go!")),
            ]),
            author: None,
            license: None,
            description: None,
            version: None,
            ui: None,
        }
    }

    #[test]
    fn per_replacement_enable_if_is_independent_of_the_rules_own_gating() {
        let config = fast_start_style_config();

        // The rule itself has no enable_if at all, so it always survives
        // regardless of Fast_Start, only the individual replacements
        // inside it are conditional.
        let resolved = config.resolved_rules(&HashMap::new());
        assert_eq!(resolved.len(), 1);

        let MemoryPatch::ReplaceString { replacements } = &resolved[0].patches[0] else {
            panic!("expected ReplaceString");
        };
        // Fast_Start unset (falsy): only the two unconditional, always-on
        // splash-text replacements survive, using their mod.json defaults,
        // since no override was supplied.
        assert_eq!(replacements.len(), 2);
        assert_eq!(replacements[0].replace, "Ready");
        assert_eq!(replacements[1].replace, "Go!");
    }

    #[test]
    fn per_replacement_enable_if_turned_on_keeps_every_replacement() {
        let config = fast_start_style_config();
        let overrides = HashMap::from([("Fast_Start".to_string(), serde_json::json!(true))]);

        let resolved = config.resolved_rules(&overrides);
        let MemoryPatch::ReplaceString { replacements } = &resolved[0].patches[0] else {
            panic!("expected ReplaceString");
        };
        // All four survive now: the two Fast_Start-gated ones plus the two
        // unconditional ones.
        assert_eq!(replacements.len(), 4);
        assert_eq!(replacements[0].replace, "player_start_time = 1;");
        assert_eq!(replacements[3].replace, "Go!");
    }

    #[test]
    fn per_replacement_enable_if_overrides_the_text_default_too() {
        let config = fast_start_style_config();
        let overrides =
            HashMap::from([("First_Start_Text".to_string(), serde_json::json!("Steady"))]);

        let resolved = config.resolved_rules(&overrides);
        let MemoryPatch::ReplaceString { replacements } = &resolved[0].patches[0] else {
            panic!("expected ReplaceString");
        };
        // First_Start_Text overridden away from its "Ready" default;
        // Second_Start_Text still falls back to its "Go!" default.
        assert_eq!(replacements[0].replace, "Steady");
        assert_eq!(replacements[1].replace, "Go!");
    }

    #[test]
    fn validate_checks_replacement_level_enable_if_same_as_rule_level() {
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![RedirectionRule {
                glob_pattern: "a".into(),
                target: None,
                mode: RedirectionMode::GracefulFallback,
                patches: vec![MemoryPatch::ReplaceString {
                    replacements: vec![StringReplacement {
                        find: "x".into(),
                        replace: "y".into(),
                        enable_if: Some("Nonexistent".to_string()),
                    }],
                }],
                enable_if: None,
            }],
            ..ModConfig::default()
        };
        let errors = config.validate().unwrap_err();
        assert!(errors.iter().any(|e| e.contains("Nonexistent")));
    }

    #[test]
    fn dropdown_needs_at_least_one_choice() {
        let param = dropdown_param("Board_Style", &[]);
        assert!(param.validate().is_err());
    }

    #[test]
    fn number_min_must_not_exceed_max() {
        let param = number_param("Fov_Boost", 10.0, 5.0);
        assert!(param.validate().is_err());
        assert!(number_param("Fov_Boost", 0.0, 20.0).validate().is_ok());
    }

    #[test]
    fn mandatory_name_is_enforced_by_validate() {
        let config = ModConfig::default();
        assert!(
            config
                .validate()
                .unwrap_err()
                .iter()
                .any(|e| e.contains("name"))
        );
    }

    #[test]
    fn enable_if_must_reference_a_known_parameter() {
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![gated_rule("a", "b", "Typo_Id")],
            parameters: vec![boolean_param("Correct_Id")],
            ..ModConfig::default()
        };
        let errors = config.validate().unwrap_err();
        assert!(errors.iter().any(|e| e.contains("Typo_Id")));
    }

    #[test]
    fn enable_if_can_reference_number_parameters() {
        // The new Rhai expressions allow Number and Text parameters to be used
        // in explicit comparisons (e.g., `resolution >= 1080`), which are valid.
        let config = ModConfig {
            name: "Test".to_string(),
            rules: vec![gated_rule("a", "b", "Fov_Boost >= 10.0")],
            parameters: vec![number_param("Fov_Boost", 0.0, 20.0)],
            ..ModConfig::default()
        };
        assert!(config.validate().is_ok());

        // But a bare number identifier is invalid because it doesn't evaluate to a boolean.
        let invalid_config = ModConfig {
            name: "Test".to_string(),
            rules: vec![gated_rule("a", "b", "Fov_Boost")],
            parameters: vec![number_param("Fov_Boost", 0.0, 20.0)],
            ..ModConfig::default()
        };
        assert!(invalid_config.validate().is_err());
    }

    #[test]
    fn enable_if_referencing_boolean_or_dropdown_is_valid() {
        let config = ModConfig {
            name: "Test".to_string(),
            // Booleans can be bare identifiers, but Dropdowns must use an explicit check
            rules: vec![
                gated_rule("a", "b", "Flag"),
                gated_rule("c", "d", "Choice != \"\""),
            ],
            parameters: vec![boolean_param("Flag"), dropdown_param("Choice", &["X"])],
            ..ModConfig::default()
        };
        assert!(config.validate().is_ok());
    }

    /// Wraps `rules` (built via [`directory_rule`]) into a minimal but
    /// valid `ModConfig`, `name` defaults to `mod_name` since these tests
    /// don't care about metadata, and writes it to `mod.json`.
    fn write_mod_config(mods_dir: &Path, mod_name: &str, rules: &HookConfig) {
        let config = ModConfig {
            name: mod_name.to_string(),
            rules: rules.rules.clone(),
            ..ModConfig::default()
        };
        config
            .write_to_path(&mods_dir.join(mod_name).join(MOD_FILE_NAME))
            .unwrap();
    }

    /// Writes a `mods.json` whose active configuration enables
    /// exactly `names`, with `order` set to match, so
    /// `active.priority_order()` reads back as `names`, in order.
    fn write_enabled_mods(mods_dir: &Path, names: &[&str]) {
        let state = ModsState {
            active: ModsPreset {
                order: names.iter().map(|s| s.to_string()).collect(),
                enabled: names.iter().map(|s| s.to_string()).collect(),
                configuration: ModConfigurations::new(),
            },
            presets: HashMap::new(),
        };
        save_mods_state(mods_dir, &state).unwrap();
    }

    #[test]
    fn first_enabled_mod_with_a_matching_rule_wins() {
        let dir = tempfile::tempdir().unwrap();
        let mods_dir = dir.path();

        write_enabled_mods(mods_dir, &["low_priority_mod", "high_priority_mod"]);
        write_mod_config(
            mods_dir,
            "high_priority_mod",
            &directory_rule("data/levels/*.dat", "mods/high"),
        );
        write_mod_config(
            mods_dir,
            "low_priority_mod",
            &directory_rule("data/levels/*.dat", "mods/low"),
        );

        // Priority follows mods.json's active enabled order, not
        // alphabetical or insertion order of the write calls above.
        let (config, skipped) = HookConfig::load_from_mods_dir(mods_dir).unwrap();
        assert!(skipped.is_empty());
        let action = config.resolve("data/levels/level1.dat", |_| true);
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from("mods/low/level1.dat")
            }
        );
    }

    #[test]
    fn mod_order_controls_redirected_reads_and_writes_to_existing_replacements() {
        let dir = tempfile::tempdir().unwrap();
        let game = dir.path().join("game");
        let mods = game.join(".supreme/mods");
        std::fs::create_dir_all(game.join("data")).unwrap();
        std::fs::create_dir_all(game.join("replacements")).unwrap();
        std::fs::write(game.join("data/file.dat"), b"original").unwrap();
        std::fs::write(game.join("replacements/first.dat"), b"first").unwrap();
        std::fs::write(game.join("replacements/second.dat"), b"second").unwrap();
        for (name, target) in [
            ("first", "replacements/first.dat"),
            ("second", "replacements/second.dat"),
        ] {
            write_mod_config(
                &mods,
                name,
                &HookConfig {
                    rules: vec![RedirectionRule {
                        glob_pattern: "data/file.dat".into(),
                        target: Some(RuleTarget::Path(target.into())),
                        mode: RedirectionMode::GracefulFallback,
                        patches: vec![],
                        enable_if: None,
                    }],
                },
            );
        }
        for (names, expected) in [
            (["first", "second"], "first.dat"),
            (["second", "first"], "second.dat"),
        ] {
            write_enabled_mods(&mods, &names);
            let (resolver, skipped) =
                HookResolver::load(&mods, game.clone(), dir.path().join("temp"));
            assert!(skipped.is_empty());
            let ResolvedAction::Redirect { replacement_path } =
                resolver.resolve_path_for_write("data/file.dat")
            else {
                panic!("write should redirect");
            };
            assert_eq!(replacement_path.file_name().unwrap(), expected);
            // Shipped replacement data is never overwritten by the seed.
            assert_eq!(
                std::fs::read(&replacement_path).unwrap(),
                if expected == "first.dat" {
                    b"first".as_slice()
                } else {
                    b"second".as_slice()
                }
            );
            assert_eq!(
                resolver.resolve_path("data/file.dat"),
                ResolvedAction::Redirect { replacement_path }
            );
        }
        assert_eq!(
            std::fs::read(game.join("data/file.dat")).unwrap(),
            b"original"
        );
    }

    #[test]
    fn mod_order_controls_patch_sequence_across_mods() {
        let dir = tempfile::tempdir().unwrap();
        let game = dir.path().join("game");
        let mods = game.join(".supreme/mods");
        std::fs::create_dir_all(game.join("data")).unwrap();
        std::fs::write(game.join("data/file.txt"), b"x").unwrap();
        for (name, find, replace) in [("append", "x", "xy"), ("collapse", "xy", "Z")] {
            write_mod_config(
                &mods,
                name,
                &HookConfig {
                    rules: vec![RedirectionRule {
                        glob_pattern: "data/file.txt".into(),
                        target: None,
                        mode: RedirectionMode::GracefulFallback,
                        enable_if: None,
                        patches: vec![MemoryPatch::ReplaceString {
                            replacements: vec![StringReplacement {
                                find: find.into(),
                                replace: replace.into(),
                                enable_if: None,
                            }],
                        }],
                    }],
                },
            );
        }
        for (names, expected, temp) in [
            (["append", "collapse"], b"Z".as_slice(), "one"),
            (["collapse", "append"], b"xy".as_slice(), "two"),
        ] {
            write_enabled_mods(&mods, &names);
            let (resolver, skipped) =
                HookResolver::load(&mods, game.clone(), dir.path().join(temp));
            assert!(skipped.is_empty());
            let ResolvedAction::Redirect { replacement_path } =
                resolver.resolve_path("data/file.txt")
            else {
                panic!("patch should stage a redirect");
            };
            assert_eq!(std::fs::read(replacement_path).unwrap(), expected);
        }
    }

    #[test]
    fn redirect_chain_restarts_at_first_mod_for_each_new_path() {
        let dir = tempfile::tempdir().unwrap();
        let game = dir.path().join("game");
        let mods = game.join(".supreme/mods");
        for folder in ["data", "mid", "final"] {
            std::fs::create_dir_all(game.join(folder)).unwrap();
        }
        std::fs::write(game.join("mid/file.txt"), b"intermediate").unwrap();
        std::fs::write(game.join("final/file.txt"), b"terminal").unwrap();
        write_mod_config(
            &mods,
            "start",
            &HookConfig {
                rules: vec![RedirectionRule {
                    glob_pattern: "data/file.txt".into(),
                    target: Some(RuleTarget::Path("mid/file.txt".into())),
                    mode: RedirectionMode::GracefulFallback,
                    patches: vec![],
                    enable_if: None,
                }],
            },
        );
        write_mod_config(
            &mods,
            "finish",
            &HookConfig {
                rules: vec![RedirectionRule {
                    glob_pattern: "mid/file.txt".into(),
                    target: Some(RuleTarget::Path("final/file.txt".into())),
                    mode: RedirectionMode::GracefulFallback,
                    patches: vec![],
                    enable_if: None,
                }],
            },
        );
        // Finish is *before* start in the merged list. It still applies
        // after start redirects into mid/file.txt, because every stage
        // starts scanning at the beginning again.
        write_enabled_mods(&mods, &["finish", "start"]);
        let (resolver, skipped) = HookResolver::load(&mods, game.clone(), dir.path().join("temp"));
        assert!(skipped.is_empty());
        assert_eq!(
            resolver.resolve_path("data/file.txt"),
            ResolvedAction::Redirect {
                replacement_path: game.join("final/file.txt")
            }
        );
        assert_eq!(
            resolver.resolve_path_for_write("data/file.txt"),
            ResolvedAction::Redirect {
                replacement_path: game.join("final/file.txt")
            }
        );
    }

    #[test]
    fn mod_with_no_matching_rule_falls_through_to_next_mod() {
        let dir = tempfile::tempdir().unwrap();
        let mods_dir = dir.path();

        write_enabled_mods(mods_dir, &["textures_mod", "levels_mod"]);
        write_mod_config(
            mods_dir,
            "textures_mod",
            &directory_rule("textures/**", "mods/textures"),
        );
        write_mod_config(
            mods_dir,
            "levels_mod",
            &directory_rule("data/levels/*.dat", "mods/levels"),
        );

        let (config, skipped) = HookConfig::load_from_mods_dir(mods_dir).unwrap();
        assert!(skipped.is_empty());
        let action = config.resolve("data/levels/level1.dat", |_| true);
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from("mods/levels/level1.dat")
            }
        );
    }

    #[test]
    fn missing_mod_json_is_skipped_not_fatal() {
        let dir = tempfile::tempdir().unwrap();
        let mods_dir = dir.path();

        // "ghost_mod" is enabled but was deleted from disk; "real_mod"
        // should still load normally.
        write_enabled_mods(mods_dir, &["ghost_mod", "real_mod"]);
        write_mod_config(
            mods_dir,
            "real_mod",
            &directory_rule("data/levels/*.dat", "mods/real"),
        );

        let (config, skipped) = HookConfig::load_from_mods_dir(mods_dir).unwrap();
        assert_eq!(skipped.len(), 1);
        assert_eq!(skipped[0].0, "ghost_mod");
        let action = config.resolve("data/levels/level1.dat", |_| true);
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from("mods/real/level1.dat")
            }
        );
    }

    #[test]
    fn invalid_mod_config_is_skipped_not_partially_applied() {
        let dir = tempfile::tempdir().unwrap();
        let mods_dir = dir.path();

        // "broken_mod" parses fine but is semantically invalid: its rule's
        // enable_if references a parameter that doesn't exist.
        write_enabled_mods(mods_dir, &["broken_mod", "real_mod"]);
        let broken = ModConfig {
            name: "Broken Mod".to_string(),
            rules: vec![RedirectionRule {
                glob_pattern: "data/levels/*.dat".into(),
                target: Some(RuleTarget::Path(PathBuf::from("mods/broken"))),
                mode: RedirectionMode::GracefulFallback,
                patches: vec![],
                enable_if: Some("Typo_Boost".to_string()),
            }],
            parameters: vec![ModParameter {
                id: "Fov_Boost".to_string(),
                name: "FOV boost".to_string(),
                help_text: "".to_string(),
                kind: ParameterKind::Number {
                    min: 0.0,
                    max: 10.0,
                    step: None,
                },
                enable_if: None,
                hidden: false,
                validation: None,
            }],
            ..ModConfig::default()
        };
        broken
            .write_to_path(&mods_dir.join("broken_mod").join(MOD_FILE_NAME))
            .unwrap();
        write_mod_config(
            mods_dir,
            "real_mod",
            &directory_rule("data/textures/*.dat", "mods/real"),
        );

        let (config, skipped) = HookConfig::load_from_mods_dir(mods_dir).unwrap();

        assert_eq!(skipped.len(), 1);
        assert_eq!(skipped[0].0, "broken_mod");
        assert!(matches!(skipped[0].1, HookConfigError::Invalid { .. }));

        // broken_mod contributed nothing, not even a permanently-off rule.
        assert!(
            config
                .find_matching_rule("data/levels/level1.dat")
                .is_none()
        );
        assert!(
            config
                .find_matching_rule("data/textures/rock.dat")
                .is_some()
        );
    }

    #[test]
    fn missing_mods_state_file_is_an_error() {
        let dir = tempfile::tempdir().unwrap();
        assert!(HookConfig::load_from_mods_dir(dir.path()).is_err());
    }

    // --- load_mods_state / save_mods_state ----------------------------
    //
    // Deliberately more forgiving than `HookConfig::load_from_mods_dir`
    // above: these back the launcher's Mods page, where "nothing saved
    // yet" (e.g. right after install, before `.supreme/mods/` exists at
    // all) is a normal state to render, not a load failure.

    #[test]
    fn load_mods_state_missing_file_is_default_not_error() {
        let dir = tempfile::tempdir().unwrap();
        // Note: `dir` itself exists, but nothing has been written into it,
        // covers both "mods dir absent" and "mods dir present, file absent".
        assert_eq!(load_mods_state(dir.path()).unwrap(), ModsState::default());
    }

    #[test]
    fn load_mods_state_reads_saved_order() {
        let dir = tempfile::tempdir().unwrap();
        write_enabled_mods(dir.path(), &["zeta_mod", "alpha_mod"]);
        assert_eq!(
            load_mods_state(dir.path()).unwrap().active.enabled,
            vec!["zeta_mod".to_string(), "alpha_mod".to_string()]
        );
    }

    #[test]
    fn load_mods_state_invalid_json_is_an_error() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(dir.path().join(MODS_STATE_FILE_NAME), b"not json").unwrap();
        assert!(load_mods_state(dir.path()).is_err());
    }

    #[test]
    fn save_mods_state_creates_mods_dir_and_round_trips() {
        let dir = tempfile::tempdir().unwrap();
        // `mods_dir` is a not-yet-created subdirectory, exercising the
        // `create_dir_all` path rather than an already-existing tempdir.
        let mods_dir = dir.path().join(".supreme/mods");

        let state = ModsState {
            active: ModsPreset {
                order: vec!["board_mod".to_string(), "trick_mod".to_string()],
                enabled: vec!["board_mod".to_string(), "trick_mod".to_string()],
                configuration: ModConfigurations::new(),
            },
            presets: HashMap::new(),
        };
        save_mods_state(&mods_dir, &state).unwrap();

        assert_eq!(load_mods_state(&mods_dir).unwrap(), state);
    }

    #[test]
    fn save_mods_state_overwrites_previous_contents() {
        let dir = tempfile::tempdir().unwrap();
        write_enabled_mods(dir.path(), &["old_mod"]);

        let new_state = ModsState {
            active: ModsPreset {
                order: vec!["new_mod".to_string()],
                enabled: vec!["new_mod".to_string()],
                configuration: ModConfigurations::new(),
            },
            presets: HashMap::new(),
        };
        save_mods_state(dir.path(), &new_state).unwrap();

        assert_eq!(
            load_mods_state(dir.path()).unwrap().active.enabled,
            vec!["new_mod".to_string()]
        );
    }

    #[test]
    fn load_from_mods_dir_reads_active_configuration_from_mods_state_separately_from_mod_json() {
        let dir = tempfile::tempdir().unwrap();
        let mods_dir = dir.path();

        write_enabled_mods(mods_dir, &["board_mod"]);
        let config = ModConfig {
            name: "Board Mod".to_string(),
            rules: vec![gated_rule(
                "Data/Boards/style.dat",
                "mods/board/${Board_Style}.dat",
                "Board_Style != \"\"",
            )],
            parameters: vec![dropdown_param("Board_Style", &["Wood", "Carbon"])],
            ..ModConfig::default()
        };
        config
            .write_to_path(&mods_dir.join("board_mod").join(MOD_FILE_NAME))
            .unwrap();

        // No configuration set on the active configuration yet, the
        // parameter reads as unset, so the gated rule shouldn't apply.
        let (unconfigured, _) = HookConfig::load_from_mods_dir(mods_dir).unwrap();
        assert!(
            unconfigured
                .find_matching_rule("Data/Boards/style.dat")
                .is_none()
        );

        // A configuration written entirely separately from mod.json, via
        // the same state file the launcher's Mods page writes, supplies
        // the value, proving load_from_mods_dir actually reads it and
        // threads it through gating and interpolation end to end.
        let mut state = load_mods_state(mods_dir).unwrap();
        state.active.configuration.insert(
            "board_mod".to_string(),
            HashMap::from([("Board_Style".to_string(), serde_json::json!("Carbon"))]),
        );
        save_mods_state(mods_dir, &state).unwrap();

        let (configured, skipped) = HookConfig::load_from_mods_dir(mods_dir).unwrap();
        assert!(skipped.is_empty());
        let action = configured.resolve("Data/Boards/style.dat", |_| true);
        assert_eq!(
            action,
            ResolvedAction::Redirect {
                replacement_path: PathBuf::from("mods/board/Carbon.dat")
            }
        );
    }
}