lazy_layered_config.cpp

Go to the documentation of this file.

#include "porytiles/infra/config/lazy_layered_config.hpp"
 
#include <any>
#include <format>
#include <functional>
#include <ostream>
#include <ranges>
#include <stdexcept>
#include <string>
 
#include "porytiles/domain/algorithms/diagnostic_stencils.hpp"
#include "porytiles/domain/config/tiles_palette_mode.hpp"
#include "porytiles/utilities/panic/panic.hpp"
#include "porytiles/utilities/source_locations.hpp"
#include "porytiles/xcut/config/config_scope_type.hpp"
#include "porytiles/xcut/config/config_value.hpp"
 
namespace porytiles {
 
// NOTE: DO NOT EDIT THIS FILE DIRECTLY. It is AUTO-GENERATED from config_schema.yaml.
// To add new config values or make other changes, edit config_schema.yaml and regenerate via:
//
//   uv run scripts/generate_config.py
 
namespace {
 
template <typename T>
void dump_single_config_value(
    std::ostream &out,
    const TextFormatter &format,
    const std::string &canonical_name,
    const std::vector<ProvenanceChainLink<T>> &chain)
{
    // Section header: bold config name with faint separator
    out << format.style(canonical_name, Style::bold) << "\n";
    out << format.style(std::string(canonical_name.size(), '-'), Style::faint) << "\n";
 
    // Find the winning link (first valid or invalid) for resolved value display
    const ProvenanceChainLink<T> *winning_link = nullptr;
    for (const auto &link : chain) {
        if (link.layer_value.state == ValidationState::valid || link.layer_value.state == ValidationState::invalid) {
            winning_link = &link;
            break;
        }
    }
 
    // Display resolved value using format_config_note, or an error/missing message
    if (winning_link != nullptr && winning_link->layer_value.state == ValidationState::valid) {
        ConfigValue<T> config_value{
            winning_link->layer_value.value.value(),
            canonical_name,
            winning_link->layer_value.source_key,
            winning_link->layer_value.source_info,
            winning_link->layer_value.source_details};
        auto note_lines = format_config_note(format, config_value);
        for (const auto &line : note_lines) {
            out << "  " << line << "\n";
        }
    }
    else if (winning_link != nullptr && winning_link->layer_value.state == ValidationState::invalid) {
        out << "  " << format.style("INVALID: " + winning_link->layer_value.error_message, Style::red) << "\n";
    }
    else {
        out << "  " << format.style("(no value found)", Style::faint) << "\n";
    }
 
    // Provider chain
    out << "\n  " << format.style("Provider Chain:", Style::faint) << "\n";
    for (const auto &link : chain) {
        switch (link.layer_value.state) {
        case ValidationState::valid:
            if (&link == winning_link) {
                out << "    " << format.style("✓", Style::green) << " " << link.provider_name;
                out << " = " << format.style(std::format("{}", link.layer_value.value.value()), Style::green);
            }
            else {
                out << "    " << format.style("○", Style::faint) << " "
                    << format.style(
                           link.provider_name + " = " + std::format("{}", link.layer_value.value.value()),
                           Style::faint);
            }
            break;
        case ValidationState::invalid:
            out << "    " << format.style("✗", Style::red) << " " << link.provider_name;
            out << " " << format.style("INVALID", Style::red);
            break;
        case ValidationState::not_provided:
            out << "    " << format.style("○", Style::faint) << " "
                << format.style(link.provider_name + " (not provided)", Style::faint);
            break;
        }
        out << "\n";
    }
    out << "\n";
}
 
} // anonymous namespace
 
void LazyLayeredConfig::add_provider(std::unique_ptr<ConfigProvider> provider)
{
    providers_.insert(providers_.begin(), std::move(provider));
    cache_.clear();
    cache_value_strings_.clear();
    source_key_.clear();
    source_.clear();
    source_details_.clear();
}
 
void LazyLayeredConfig::dump_config(std::ostream &out, ConfigScopeType type, const std::string &scope) const
{
    const std::string header_str = "Configuration dump for {} '{}'";
    auto type_str = to_string(type);
    std::string header = std::vformat(header_str, std::make_format_args(type_str, scope));
    out << format_->format(
               header_str, FormatParam{to_string(type), Style::bold}, FormatParam{scope, Style::bold | Style::cyan})
        << "\n";
    out << format_->style(std::string(header.size(), '='), Style::faint) << "\n\n";
    dump_single_config_value(
        out, *format_, "Number Of Tiles In Primary", num_tiles_in_primary_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Number Of Tiles Total", num_tiles_total_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Number Of Metatiles In Primary", num_metatiles_in_primary_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Number Of Metatiles Total", num_metatiles_total_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Number Of Palettes In Primary", num_palettes_in_primary_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Number Of Palettes Total", num_palettes_total_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Max Map Data Size", max_map_data_size_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Number Of Tiles Per Metatile", num_tiles_per_metatile_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Extrinsic Transparency", extrinsic_transparency_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Ignore Triple Layer Content", ignore_triple_layer_content_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Tiles Edit Mode", tiles_edit_mode_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Palettes Edit Mode", palettes_edit_mode_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Palette Hints Enabled", palette_hints_enabled_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Palette Hints", palette_hints_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Packing Strategy", packing_strategy_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Packing Strategy Params", packing_strategy_params_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Tile Sharing Packing", tile_sharing_packing_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Tile Sharing Alignment", tile_sharing_alignment_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Tiles Palette Mode", tiles_palette_mode_provenance_chain(type, scope));
    dump_single_config_value(
        out,
        *format_,
        "Global Animation Palette Resolution Strategy",
        global_anim_palette_resolution_strategy_provenance_chain(type, scope));
    dump_single_config_value(
        out,
        *format_,
        "Global Animation Key Frame Resolution Strategy",
        global_anim_key_frame_resolution_strategy_provenance_chain(type, scope));
    dump_single_config_value(
        out,
        *format_,
        "Global Animation Multi-Palette Subtile Resolution Strategy",
        global_anim_multi_palette_subtile_resolution_strategy_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Global Frame Linking", global_frame_linking_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Per-Animation Overrides", per_anim_overrides_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Cross-Tileset Animation Linking", cross_tileset_anim_linking_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Verify Checksums", verify_checksums_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Primary Pairing Mode", primary_pairing_mode_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Primary Pairing Partners", primary_pairing_partners_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Diagnostic Warnings Exclude", diagnostic_warnings_exclude_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Diagnostic Warnings Include", diagnostic_warnings_include_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Diagnostic Remarks Exclude", diagnostic_remarks_exclude_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Diagnostic Remarks Include", diagnostic_remarks_include_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Tileset Paths Primary Source", tileset_paths_primary_src_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Tileset Paths Primary Bin", tileset_paths_primary_bin_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Tileset Paths Secondary Source", tileset_paths_secondary_src_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Tileset Paths Secondary Bin", tileset_paths_secondary_bin_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Metatile Attribute Size", metatile_attribute_size_provenance_chain(type, scope));
    dump_single_config_value(
        out,
        *format_,
        "Metatile Attribute Declaration Size",
        metatile_attribute_declaration_size_provenance_chain(type, scope));
    dump_single_config_value(
        out, *format_, "Metatile Attribute Fields", metatile_attribute_fields_provenance_chain(type, scope));
    dump_single_config_value(
        out,
        *format_,
        "Metatile Attribute Field Overrides",
        metatile_attribute_field_overrides_provenance_chain(type, scope));
    dump_single_config_value(out, *format_, "Role Pins", role_pins_provenance_chain(type, scope));
    dump_single_config_value(
        out,
        *format_,
        "Tileset Animations Wire Anim Code",
        tileset_animations_wire_anim_code_provenance_chain(type, scope));
}
 
template <typename T>
ChainableResult<ConfigValue<T>> LazyLayeredConfig::resolve_config_value(
    const std::string &cache_key,
    const std::string &canonical_name,
    std::function<LayerValue<T>(const ConfigProvider &)> provider_call) const
{
    // Check if already cached
    if (cache_.contains(cache_key)) {
        T cached_value{};
        try {
            cached_value = std::any_cast<T>(cache_.at(cache_key));
        }
        catch (const std::bad_any_cast &) {
            panic(format_->format(
                "bad_any_cast for cache key '{}': cached type does not match requested type", cache_key));
        }
        std::string cached_source_key = source_key_.at(cache_key);
        std::string source = source_.at(cache_key);
        std::vector<std::string> source_details = source_details_.at(cache_key);
        return ConfigValue<T>{cached_value, canonical_name, cached_source_key, source, source_details};
    }
 
    // Search through providers in priority order
    for (const auto &provider : providers_) {
        LayerValue<T> layer_value = provider_call(*provider);
 
        // Check if provider found an invalid value - stop immediately and return error
        if (layer_value.state == ValidationState::invalid) {
            const auto source_info = format_->format("{}", layer_value.source_info);
            std::vector<std::string> error_lines;
            error_lines.push_back(format_->format(
                "Invalid value for '{}' from config source '{}':",
                FormatParam{canonical_name, Style::bold},
                FormatParam{source_info, Style::bold}));
            error_lines.emplace_back();
            error_lines.push_back(format_->format("{}", layer_value.error_message));
 
            if (!layer_value.source_details.empty()) {
                error_lines.emplace_back(""); // Blank line separator
                for (const auto &detail : layer_value.source_details) {
                    error_lines.push_back(detail);
                }
            }
 
            return FormattableError{error_lines};
        }
 
        // Check if provider has a valid value
        if (layer_value.state == ValidationState::valid) {
            T resolved_value = layer_value.value.value();
            cache_[cache_key] = resolved_value;
            cache_value_strings_[cache_key] = std::format("{}", resolved_value);
            source_key_[cache_key] = layer_value.source_key;
            std::string source = format_->format("{}", layer_value.source_info);
            source_[cache_key] = source;
            source_details_[cache_key] = layer_value.source_details;
            return ConfigValue<T>{
                resolved_value, canonical_name, layer_value.source_key, source, layer_value.source_details};
        }
 
        // Otherwise, state is not_provided - continue to next provider
        if (layer_value.state == ValidationState::not_provided) {
            continue;
        }
 
        panic("hit unexpected ValidationState");
    }
 
    // No value found in any layer - this is a programmer error
    panic(format_->format("no value found for '{}' in any config layer", cache_key));
}
 
template <typename T>
std::vector<ProvenanceChainLink<T>>
LazyLayeredConfig::collect_provenance_chain(std::function<LayerValue<T>(const ConfigProvider &)> provider_call) const
{
    std::vector<ProvenanceChainLink<T>> chain;
    chain.reserve(providers_.size());
 
    for (const auto &provider : providers_) {
        LayerValue<T> layer_value = provider_call(*provider);
        chain.push_back(ProvenanceChainLink<T>{provider->name(), std::move(layer_value)});
    }
 
    return chain;
}
 
ChainableResult<ConfigValue<std::size_t>>
LazyLayeredConfig::num_tiles_in_primary_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::size_t>(
        key, "Number Of Tiles In Primary", [&type, &scope](const ConfigProvider &provider) {
            return provider.num_tiles_in_primary(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::size_t>>
LazyLayeredConfig::num_tiles_total_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::size_t>(
        key, "Number Of Tiles Total", [&type, &scope](const ConfigProvider &provider) {
            return provider.num_tiles_total(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::size_t>>
LazyLayeredConfig::num_metatiles_in_primary_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::size_t>(
        key, "Number Of Metatiles In Primary", [&type, &scope](const ConfigProvider &provider) {
            return provider.num_metatiles_in_primary(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::size_t>>
LazyLayeredConfig::num_metatiles_total_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::size_t>(
        key, "Number Of Metatiles Total", [&type, &scope](const ConfigProvider &provider) {
            return provider.num_metatiles_total(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::size_t>>
LazyLayeredConfig::num_palettes_in_primary_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::size_t>(
        key, "Number Of Palettes In Primary", [&type, &scope](const ConfigProvider &provider) {
            return provider.num_palettes_in_primary(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::size_t>>
LazyLayeredConfig::num_palettes_total_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::size_t>(
        key, "Number Of Palettes Total", [&type, &scope](const ConfigProvider &provider) {
            return provider.num_palettes_total(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::size_t>>
LazyLayeredConfig::max_map_data_size_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::size_t>(key, "Max Map Data Size", [&type, &scope](const ConfigProvider &provider) {
        return provider.max_map_data_size(type, scope);
    });
}
 
ChainableResult<ConfigValue<std::size_t>>
LazyLayeredConfig::num_tiles_per_metatile_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::size_t>(
        key, "Number Of Tiles Per Metatile", [&type, &scope](const ConfigProvider &provider) {
            return provider.num_tiles_per_metatile(type, scope);
        });
}
 
ChainableResult<ConfigValue<Rgba32>>
LazyLayeredConfig::extrinsic_transparency_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<Rgba32>(key, "Extrinsic Transparency", [&type, &scope](const ConfigProvider &provider) {
        return provider.extrinsic_transparency(type, scope);
    });
}
 
ChainableResult<ConfigValue<bool>>
LazyLayeredConfig::ignore_triple_layer_content_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<bool>(
        key, "Ignore Triple Layer Content", [&type, &scope](const ConfigProvider &provider) {
            return provider.ignore_triple_layer_content(type, scope);
        });
}
 
ChainableResult<ConfigValue<ArtifactEditMode>>
LazyLayeredConfig::tiles_edit_mode_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<ArtifactEditMode>(
        key, "Tiles Edit Mode", [&type, &scope](const ConfigProvider &provider) {
            return provider.tiles_edit_mode(type, scope);
        });
}
 
ChainableResult<ConfigValue<ArtifactEditMode>>
LazyLayeredConfig::palettes_edit_mode_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<ArtifactEditMode>(
        key, "Palettes Edit Mode", [&type, &scope](const ConfigProvider &provider) {
            return provider.palettes_edit_mode(type, scope);
        });
}
 
ChainableResult<ConfigValue<bool>>
LazyLayeredConfig::palette_hints_enabled_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<bool>(key, "Palette Hints Enabled", [&type, &scope](const ConfigProvider &provider) {
        return provider.palette_hints_enabled(type, scope);
    });
}
 
ChainableResult<ConfigValue<std::vector<PaletteHint>>>
LazyLayeredConfig::palette_hints_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::vector<PaletteHint>>(
        key, "Palette Hints", [&type, &scope](const ConfigProvider &provider) {
            return provider.palette_hints(type, scope);
        });
}
 
ChainableResult<ConfigValue<PackingStrategyType>>
LazyLayeredConfig::packing_strategy_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<PackingStrategyType>(
        key, "Packing Strategy", [&type, &scope](const ConfigProvider &provider) {
            return provider.packing_strategy(type, scope);
        });
}
 
ChainableResult<ConfigValue<PackingStrategyParams>>
LazyLayeredConfig::packing_strategy_params_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<PackingStrategyParams>(
        key, "Packing Strategy Params", [&type, &scope](const ConfigProvider &provider) {
            return provider.packing_strategy_params(type, scope);
        });
}
 
ChainableResult<ConfigValue<TileSharingPacking>>
LazyLayeredConfig::tile_sharing_packing_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<TileSharingPacking>(
        key, "Tile Sharing Packing", [&type, &scope](const ConfigProvider &provider) {
            return provider.tile_sharing_packing(type, scope);
        });
}
 
ChainableResult<ConfigValue<TileSharingAlignment>>
LazyLayeredConfig::tile_sharing_alignment_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<TileSharingAlignment>(
        key, "Tile Sharing Alignment", [&type, &scope](const ConfigProvider &provider) {
            return provider.tile_sharing_alignment(type, scope);
        });
}
 
ChainableResult<ConfigValue<TilesPaletteMode>>
LazyLayeredConfig::tiles_palette_mode_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<TilesPaletteMode>(
        key, "Tiles Palette Mode", [&type, &scope](const ConfigProvider &provider) {
            return provider.tiles_palette_mode(type, scope);
        });
}
 
ChainableResult<ConfigValue<AnimPaletteResolutionStrategy>>
LazyLayeredConfig::global_anim_palette_resolution_strategy_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<AnimPaletteResolutionStrategy>(
        key, "Global Animation Palette Resolution Strategy", [&type, &scope](const ConfigProvider &provider) {
            return provider.global_anim_palette_resolution_strategy(type, scope);
        });
}
 
ChainableResult<ConfigValue<AnimKeyFrameResolutionStrategy>>
LazyLayeredConfig::global_anim_key_frame_resolution_strategy_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<AnimKeyFrameResolutionStrategy>(
        key, "Global Animation Key Frame Resolution Strategy", [&type, &scope](const ConfigProvider &provider) {
            return provider.global_anim_key_frame_resolution_strategy(type, scope);
        });
}
 
ChainableResult<ConfigValue<AnimMultiPaletteSubtileResolutionStrategy>>
LazyLayeredConfig::global_anim_multi_palette_subtile_resolution_strategy_raw(
    ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<AnimMultiPaletteSubtileResolutionStrategy>(
        key,
        "Global Animation Multi-Palette Subtile Resolution Strategy",
        [&type, &scope](const ConfigProvider &provider) {
            return provider.global_anim_multi_palette_subtile_resolution_strategy(type, scope);
        });
}
 
ChainableResult<ConfigValue<FrameLinking>>
LazyLayeredConfig::global_frame_linking_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<FrameLinking>(
        key, "Global Frame Linking", [&type, &scope](const ConfigProvider &provider) {
            return provider.global_frame_linking(type, scope);
        });
}
 
ChainableResult<ConfigValue<PerAnimOverrides>>
LazyLayeredConfig::per_anim_overrides_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<PerAnimOverrides>(
        key, "Per-Animation Overrides", [&type, &scope](const ConfigProvider &provider) {
            return provider.per_anim_overrides(type, scope);
        });
}
 
ChainableResult<ConfigValue<bool>>
LazyLayeredConfig::cross_tileset_anim_linking_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<bool>(
        key, "Cross-Tileset Animation Linking", [&type, &scope](const ConfigProvider &provider) {
            return provider.cross_tileset_anim_linking(type, scope);
        });
}
 
ChainableResult<ConfigValue<bool>>
LazyLayeredConfig::verify_checksums_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<bool>(key, "Verify Checksums", [&type, &scope](const ConfigProvider &provider) {
        return provider.verify_checksums(type, scope);
    });
}
 
ChainableResult<ConfigValue<PrimaryPairingMode>>
LazyLayeredConfig::primary_pairing_mode_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<PrimaryPairingMode>(
        key, "Primary Pairing Mode", [&type, &scope](const ConfigProvider &provider) {
            return provider.primary_pairing_mode(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::vector<std::string>>>
LazyLayeredConfig::primary_pairing_partners_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::vector<std::string>>(
        key, "Primary Pairing Partners", [&type, &scope](const ConfigProvider &provider) {
            return provider.primary_pairing_partners(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::vector<std::string>>>
LazyLayeredConfig::diagnostic_warnings_exclude_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::vector<std::string>>(
        key, "Diagnostic Warnings Exclude", [&type, &scope](const ConfigProvider &provider) {
            return provider.diagnostic_warnings_exclude(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::vector<std::string>>>
LazyLayeredConfig::diagnostic_warnings_include_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::vector<std::string>>(
        key, "Diagnostic Warnings Include", [&type, &scope](const ConfigProvider &provider) {
            return provider.diagnostic_warnings_include(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::vector<std::string>>>
LazyLayeredConfig::diagnostic_remarks_exclude_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::vector<std::string>>(
        key, "Diagnostic Remarks Exclude", [&type, &scope](const ConfigProvider &provider) {
            return provider.diagnostic_remarks_exclude(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::vector<std::string>>>
LazyLayeredConfig::diagnostic_remarks_include_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::vector<std::string>>(
        key, "Diagnostic Remarks Include", [&type, &scope](const ConfigProvider &provider) {
            return provider.diagnostic_remarks_include(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::string>>
LazyLayeredConfig::tileset_paths_primary_src_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::string>(
        key, "Tileset Paths Primary Source", [&type, &scope](const ConfigProvider &provider) {
            return provider.tileset_paths_primary_src(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::string>>
LazyLayeredConfig::tileset_paths_primary_bin_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::string>(
        key, "Tileset Paths Primary Bin", [&type, &scope](const ConfigProvider &provider) {
            return provider.tileset_paths_primary_bin(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::string>>
LazyLayeredConfig::tileset_paths_secondary_src_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::string>(
        key, "Tileset Paths Secondary Source", [&type, &scope](const ConfigProvider &provider) {
            return provider.tileset_paths_secondary_src(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::string>>
LazyLayeredConfig::tileset_paths_secondary_bin_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::string>(
        key, "Tileset Paths Secondary Bin", [&type, &scope](const ConfigProvider &provider) {
            return provider.tileset_paths_secondary_bin(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::optional<std::size_t>>>
LazyLayeredConfig::metatile_attribute_size_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::optional<std::size_t>>(
        key, "Metatile Attribute Size", [&type, &scope](const ConfigProvider &provider) {
            return provider.metatile_attribute_size(type, scope);
        });
}
 
ChainableResult<ConfigValue<std::optional<std::size_t>>>
LazyLayeredConfig::metatile_attribute_declaration_size_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<std::optional<std::size_t>>(
        key, "Metatile Attribute Declaration Size", [&type, &scope](const ConfigProvider &provider) {
            return provider.metatile_attribute_declaration_size(type, scope);
        });
}
 
ChainableResult<ConfigValue<MetatileAttributeFieldDefinitions>>
LazyLayeredConfig::metatile_attribute_fields_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<MetatileAttributeFieldDefinitions>(
        key, "Metatile Attribute Fields", [&type, &scope](const ConfigProvider &provider) {
            return provider.metatile_attribute_fields(type, scope);
        });
}
 
ChainableResult<ConfigValue<MetatileAttributeFieldOverrides>>
LazyLayeredConfig::metatile_attribute_field_overrides_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<MetatileAttributeFieldOverrides>(
        key, "Metatile Attribute Field Overrides", [&type, &scope](const ConfigProvider &provider) {
            return provider.metatile_attribute_field_overrides(type, scope);
        });
}
 
ChainableResult<ConfigValue<RolePinDefinitions>>
LazyLayeredConfig::role_pins_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<RolePinDefinitions>(
        key, "Role Pins", [&type, &scope](const ConfigProvider &provider) { return provider.role_pins(type, scope); });
}
 
ChainableResult<ConfigValue<bool>>
LazyLayeredConfig::tileset_animations_wire_anim_code_raw(ConfigScopeType type, const std::string &scope) const
{
    const auto name = extract_function_name();
    // Strip the _raw suffix from the function name for cache key
    const auto base_name = name.substr(0, name.size() - 4);
    const auto key = to_string(type) + ":" + scope + ":" + base_name;
    return resolve_config_value<bool>(
        key, "Tileset Animations Wire Anim Code", [&type, &scope](const ConfigProvider &provider) {
            return provider.tileset_animations_wire_anim_code(type, scope);
        });
}
 
std::vector<ProvenanceChainLink<std::size_t>>
LazyLayeredConfig::num_tiles_in_primary_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::size_t>(
        [&type, &scope](const ConfigProvider &provider) { return provider.num_tiles_in_primary(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::size_t>>
LazyLayeredConfig::num_tiles_total_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::size_t>(
        [&type, &scope](const ConfigProvider &provider) { return provider.num_tiles_total(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::size_t>>
LazyLayeredConfig::num_metatiles_in_primary_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::size_t>(
        [&type, &scope](const ConfigProvider &provider) { return provider.num_metatiles_in_primary(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::size_t>>
LazyLayeredConfig::num_metatiles_total_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::size_t>(
        [&type, &scope](const ConfigProvider &provider) { return provider.num_metatiles_total(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::size_t>>
LazyLayeredConfig::num_palettes_in_primary_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::size_t>(
        [&type, &scope](const ConfigProvider &provider) { return provider.num_palettes_in_primary(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::size_t>>
LazyLayeredConfig::num_palettes_total_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::size_t>(
        [&type, &scope](const ConfigProvider &provider) { return provider.num_palettes_total(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::size_t>>
LazyLayeredConfig::max_map_data_size_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::size_t>(
        [&type, &scope](const ConfigProvider &provider) { return provider.max_map_data_size(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::size_t>>
LazyLayeredConfig::num_tiles_per_metatile_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::size_t>(
        [&type, &scope](const ConfigProvider &provider) { return provider.num_tiles_per_metatile(type, scope); });
}
 
std::vector<ProvenanceChainLink<Rgba32>>
LazyLayeredConfig::extrinsic_transparency_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<Rgba32>(
        [&type, &scope](const ConfigProvider &provider) { return provider.extrinsic_transparency(type, scope); });
}
 
std::vector<ProvenanceChainLink<bool>>
LazyLayeredConfig::ignore_triple_layer_content_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<bool>(
        [&type, &scope](const ConfigProvider &provider) { return provider.ignore_triple_layer_content(type, scope); });
}
 
std::vector<ProvenanceChainLink<ArtifactEditMode>>
LazyLayeredConfig::tiles_edit_mode_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<ArtifactEditMode>(
        [&type, &scope](const ConfigProvider &provider) { return provider.tiles_edit_mode(type, scope); });
}
 
std::vector<ProvenanceChainLink<ArtifactEditMode>>
LazyLayeredConfig::palettes_edit_mode_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<ArtifactEditMode>(
        [&type, &scope](const ConfigProvider &provider) { return provider.palettes_edit_mode(type, scope); });
}
 
std::vector<ProvenanceChainLink<bool>>
LazyLayeredConfig::palette_hints_enabled_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<bool>(
        [&type, &scope](const ConfigProvider &provider) { return provider.palette_hints_enabled(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::vector<PaletteHint>>>
LazyLayeredConfig::palette_hints_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::vector<PaletteHint>>(
        [&type, &scope](const ConfigProvider &provider) { return provider.palette_hints(type, scope); });
}
 
std::vector<ProvenanceChainLink<PackingStrategyType>>
LazyLayeredConfig::packing_strategy_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<PackingStrategyType>(
        [&type, &scope](const ConfigProvider &provider) { return provider.packing_strategy(type, scope); });
}
 
std::vector<ProvenanceChainLink<PackingStrategyParams>>
LazyLayeredConfig::packing_strategy_params_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<PackingStrategyParams>(
        [&type, &scope](const ConfigProvider &provider) { return provider.packing_strategy_params(type, scope); });
}
 
std::vector<ProvenanceChainLink<TileSharingPacking>>
LazyLayeredConfig::tile_sharing_packing_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<TileSharingPacking>(
        [&type, &scope](const ConfigProvider &provider) { return provider.tile_sharing_packing(type, scope); });
}
 
std::vector<ProvenanceChainLink<TileSharingAlignment>>
LazyLayeredConfig::tile_sharing_alignment_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<TileSharingAlignment>(
        [&type, &scope](const ConfigProvider &provider) { return provider.tile_sharing_alignment(type, scope); });
}
 
std::vector<ProvenanceChainLink<TilesPaletteMode>>
LazyLayeredConfig::tiles_palette_mode_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<TilesPaletteMode>(
        [&type, &scope](const ConfigProvider &provider) { return provider.tiles_palette_mode(type, scope); });
}
 
std::vector<ProvenanceChainLink<AnimPaletteResolutionStrategy>>
LazyLayeredConfig::global_anim_palette_resolution_strategy_provenance_chain(
    ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<AnimPaletteResolutionStrategy>([&type, &scope](const ConfigProvider &provider) {
        return provider.global_anim_palette_resolution_strategy(type, scope);
    });
}
 
std::vector<ProvenanceChainLink<AnimKeyFrameResolutionStrategy>>
LazyLayeredConfig::global_anim_key_frame_resolution_strategy_provenance_chain(
    ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<AnimKeyFrameResolutionStrategy>([&type, &scope](const ConfigProvider &provider) {
        return provider.global_anim_key_frame_resolution_strategy(type, scope);
    });
}
 
std::vector<ProvenanceChainLink<AnimMultiPaletteSubtileResolutionStrategy>>
LazyLayeredConfig::global_anim_multi_palette_subtile_resolution_strategy_provenance_chain(
    ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<AnimMultiPaletteSubtileResolutionStrategy>(
        [&type, &scope](const ConfigProvider &provider) {
            return provider.global_anim_multi_palette_subtile_resolution_strategy(type, scope);
        });
}
 
std::vector<ProvenanceChainLink<FrameLinking>>
LazyLayeredConfig::global_frame_linking_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<FrameLinking>(
        [&type, &scope](const ConfigProvider &provider) { return provider.global_frame_linking(type, scope); });
}
 
std::vector<ProvenanceChainLink<PerAnimOverrides>>
LazyLayeredConfig::per_anim_overrides_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<PerAnimOverrides>(
        [&type, &scope](const ConfigProvider &provider) { return provider.per_anim_overrides(type, scope); });
}
 
std::vector<ProvenanceChainLink<bool>>
LazyLayeredConfig::cross_tileset_anim_linking_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<bool>(
        [&type, &scope](const ConfigProvider &provider) { return provider.cross_tileset_anim_linking(type, scope); });
}
 
std::vector<ProvenanceChainLink<bool>>
LazyLayeredConfig::verify_checksums_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<bool>(
        [&type, &scope](const ConfigProvider &provider) { return provider.verify_checksums(type, scope); });
}
 
std::vector<ProvenanceChainLink<PrimaryPairingMode>>
LazyLayeredConfig::primary_pairing_mode_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<PrimaryPairingMode>(
        [&type, &scope](const ConfigProvider &provider) { return provider.primary_pairing_mode(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::vector<std::string>>>
LazyLayeredConfig::primary_pairing_partners_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::vector<std::string>>(
        [&type, &scope](const ConfigProvider &provider) { return provider.primary_pairing_partners(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::vector<std::string>>>
LazyLayeredConfig::diagnostic_warnings_exclude_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::vector<std::string>>(
        [&type, &scope](const ConfigProvider &provider) { return provider.diagnostic_warnings_exclude(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::vector<std::string>>>
LazyLayeredConfig::diagnostic_warnings_include_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::vector<std::string>>(
        [&type, &scope](const ConfigProvider &provider) { return provider.diagnostic_warnings_include(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::vector<std::string>>>
LazyLayeredConfig::diagnostic_remarks_exclude_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::vector<std::string>>(
        [&type, &scope](const ConfigProvider &provider) { return provider.diagnostic_remarks_exclude(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::vector<std::string>>>
LazyLayeredConfig::diagnostic_remarks_include_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::vector<std::string>>(
        [&type, &scope](const ConfigProvider &provider) { return provider.diagnostic_remarks_include(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::string>>
LazyLayeredConfig::tileset_paths_primary_src_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::string>(
        [&type, &scope](const ConfigProvider &provider) { return provider.tileset_paths_primary_src(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::string>>
LazyLayeredConfig::tileset_paths_primary_bin_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::string>(
        [&type, &scope](const ConfigProvider &provider) { return provider.tileset_paths_primary_bin(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::string>>
LazyLayeredConfig::tileset_paths_secondary_src_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::string>(
        [&type, &scope](const ConfigProvider &provider) { return provider.tileset_paths_secondary_src(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::string>>
LazyLayeredConfig::tileset_paths_secondary_bin_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::string>(
        [&type, &scope](const ConfigProvider &provider) { return provider.tileset_paths_secondary_bin(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::optional<std::size_t>>>
LazyLayeredConfig::metatile_attribute_size_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::optional<std::size_t>>(
        [&type, &scope](const ConfigProvider &provider) { return provider.metatile_attribute_size(type, scope); });
}
 
std::vector<ProvenanceChainLink<std::optional<std::size_t>>>
LazyLayeredConfig::metatile_attribute_declaration_size_provenance_chain(
    ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<std::optional<std::size_t>>([&type, &scope](const ConfigProvider &provider) {
        return provider.metatile_attribute_declaration_size(type, scope);
    });
}
 
std::vector<ProvenanceChainLink<MetatileAttributeFieldDefinitions>>
LazyLayeredConfig::metatile_attribute_fields_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<MetatileAttributeFieldDefinitions>(
        [&type, &scope](const ConfigProvider &provider) { return provider.metatile_attribute_fields(type, scope); });
}
 
std::vector<ProvenanceChainLink<MetatileAttributeFieldOverrides>>
LazyLayeredConfig::metatile_attribute_field_overrides_provenance_chain(
    ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<MetatileAttributeFieldOverrides>([&type, &scope](const ConfigProvider &provider) {
        return provider.metatile_attribute_field_overrides(type, scope);
    });
}
 
std::vector<ProvenanceChainLink<RolePinDefinitions>>
LazyLayeredConfig::role_pins_provenance_chain(ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<RolePinDefinitions>(
        [&type, &scope](const ConfigProvider &provider) { return provider.role_pins(type, scope); });
}
 
std::vector<ProvenanceChainLink<bool>> LazyLayeredConfig::tileset_animations_wire_anim_code_provenance_chain(
    ConfigScopeType type, const std::string &scope) const
{
    return collect_provenance_chain<bool>([&type, &scope](const ConfigProvider &provider) {
        return provider.tileset_animations_wire_anim_code(type, scope);
    });
}
 
} // namespace porytiles