diff --git a/.gitignore b/.gitignore
index 76b1e1f1f..ee7f7c9b6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,10 @@
 /research
 /out
 
+# Local build logs
+/_build_exit.txt
+/_build_release.log
+
 # Visual Studio
 *.sln
 *.VC.*
diff --git a/README.md b/README.md
index 43eb8cf72..73aa9a6bb 100644
--- a/README.md
+++ b/README.md
@@ -53,7 +53,7 @@ Most important:
 
 Multiplayer:
 * Increased (and configurable) tick rate
-* TOML-based `ADS` dedicated server configuration with per-level rules, on-demand reloading, rule presets, and on-the-fly game type switching
+* TOML-based `ADS` dedicated server configuration with per-level rules, on-demand reloading, and on-the-fly game type switching
 * "GunGame" game mode
 * Competitive match framework including "ready up" system and overtime
 * Improved gaussian distribution method for bullet spread
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index dc1b6ea99..ac80fde9c 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -45,6 +45,7 @@ Version 1.4.0 (Lupin): Not yet released
   - Servers describe their votable levels, game types, and mutator options to clients
   - `Level` and `Match` can now select a game type and any number of mutators (with their options) for the voted level
   - Add a vote panel for calling any vote the server allows, opened during gameplay with the bindable `Call Vote Menu` control (`F4` by default)
+  - The vote panel pre-selects the chosen level's game type and the server's currently active mutator set, with buttons to reset the game type and restore the `Base` or `Current` mutator set
   - Vote HUD notification now shows live tally, time remaining, and whether you have already voted
 - Add FactionFiles-integrated multiplayer statistics tracking
   - Dedicated servers with a configured `fflink_gsk` report a gameplay event stream to FactionFiles
@@ -114,6 +115,7 @@ Version 1.4.0 (Lupin): Not yet released
 - Add `spectate_cameras` console command to toggle showing camera meshes at static camera locations while free look spectating
 - Deprecated and removed legacy GunGame dedicated server config items now that `GG` is an actual gametype
 - Deprecated and removed legacy critical hits dedicated server config items now that it is a mutator
+- Deprecated and removed the `rules_presets` dedicated server config item and its `rules_preset_aliases` table
 - Default inactivity tracking for players in dedicated servers to `true`, but kicking inactive players to `false`
 - Add `-debug` command line switch to enable additional debug logging, intended to help identify long-standing netcode issues that are difficult to nail down.
 - Add automatic team balance option which handles unbalanced teams mid-game and stops players from switching teams if it would unbalance them
@@ -145,6 +147,8 @@ Version 1.4.0 (Lupin): Not yet released
 - Support af://demo/ID on the af protocol to play demos from FactionFiles
 - Set client netfps to 40, server default netfps to 40 (configurable)
 - Make color pickers in the level editor open at the current color instead of black
+- A voted level now derives its rules from the server's base rules plus the voted mutator set, rather than inheriting the rules of whichever rotation slot happens to name that level
+- `sv_gametype` against a level in the rotation now rebuilds the rules from the base rules for the new game type instead of retargeting the old game type's rules in place
 
 [@is-this-c](https://github.com/is-this-c)
 - Rewrite `VArray` to fix crashes due to MinGW
@@ -226,6 +230,8 @@ Version 1.4.0 (Lupin): Not yet released
 - Fix particle emitters created from `emitters.tbl` templates inheriting uninitialized UID and `Active Distance` values that could make their particles silently fail to spawn in rare cases
 - Fix spacebar (when bound to `Jump`) moving freelook camera upward when typing in chat
 - Fix crash risk when leaving a match or changing levels by keeping animation skeletons loaded while animation instances are still playing them, instead of unloading as soon as no character references them
+- Fix dedicated servers not loading `alpinefaction.vpp`, which prevented `af_level_quirks.tbl` from loading and left known run maps unrecognized
+- Fix potential crash when an Alpine options `.tbl` file contains an unrecognized option name
 
 [@is-this-c](https://github.com/is-this-c)
 - Clear cached server config output after a shuffle of a server's rotation
diff --git a/game_patch/graphics/gr.cpp b/game_patch/graphics/gr.cpp
index 74b1ec650..38a27d65a 100644
--- a/game_patch/graphics/gr.cpp
+++ b/game_patch/graphics/gr.cpp
@@ -618,10 +618,9 @@ ConsoleCommand2 pow2_tex_cmd{
 void evaluate_pow2tex(const rf::String& level_filename) {
     // if dbg_pow2tex is active, use manual override instead of level filename lookup
     if (!override_pow2tex) {
-        bool should_p2t_fix = false;
-
-        if (is_p2t_fix_level(level_filename)) {
-            should_p2t_fix = true;
+        const bool should_p2t_fix = is_p2t_fix_level(level_filename);
+        // Renderer-only, so a dedicated server has nothing to report.
+        if (!rf::is_dedicated_server && should_p2t_fix) {
             rf::console::print("Applying power of 2 texture fix to known affected level {}", level_filename);
         }
 
@@ -631,7 +630,7 @@ void evaluate_pow2tex(const rf::String& level_filename) {
     // Always sync D3D11 state with current p2t value at level load
     if (g_game_config.renderer == GameConfig::Renderer::d3d11) {
         gr::d3d11::set_pow2_tex_active(rf::gr::d3d::p2t != 0);
-        if (is_sky_fix_level(level_filename)) {
+        if (!rf::is_dedicated_server && is_sky_fix_level(level_filename)) {
             rf::console::print("Applying sky fix to known affected level {}", level_filename);
         }
     }
diff --git a/game_patch/hud/multi_spectate.cpp b/game_patch/hud/multi_spectate.cpp
index 8e8c6e7f9..6342167d8 100644
--- a/game_patch/hud/multi_spectate.cpp
+++ b/game_patch/hud/multi_spectate.cpp
@@ -1637,9 +1637,12 @@ void multi_spectate_process_bind_input()
     const bool player_mode = g_spectate_mode_enabled;   // first/third person
     const bool static_mode = g_spectate_static_active;   // static cameras
     const bool bindable = player_mode || static_mode;
-    // Still consume the numpad counters while typing (so they don't queue up), but don't act on
-    // them - the console/chat-say box uses the separate character buffer for typing.
-    const bool typing = rf::console::console_is_visible() || rf::multi_chat_is_say_visible();
+    // Still consume the numpad counters while an overlay owns input (so they don't queue up), but
+    // don't act on them - the console/chat-say box reads the separate character buffer, and the
+    // vote panel's own rows sit under the numpad keys whether or not a text box has focus.
+    const bool typing = rf::console::console_is_visible() ||
+    rf::multi_chat_is_say_visible() ||
+    vote_panel_is_gameplay_overlay_active();
 
     if (rf::key_get_and_reset_down_counter(rf::KEY_PADENTER) > 0 && !typing) {
         g_spectate_bind_dialog_open = bindable && !g_spectate_bind_dialog_open;
diff --git a/game_patch/input/control_input_filter.cpp b/game_patch/input/control_input_filter.cpp
index e03bc68e6..2b1eb89b0 100644
--- a/game_patch/input/control_input_filter.cpp
+++ b/game_patch/input/control_input_filter.cpp
@@ -44,9 +44,11 @@ ControlInputInjection resolve_injection(rf::ControlConfig* ccp, rf::ControlConfi
 FunHook<bool(rf::ControlConfig*, rf::ControlConfigAction, bool*)> control_config_check_pressed_hook{
     0x0043D4F0,
     [](rf::ControlConfig* ccp, rf::ControlConfigAction action, bool* just_pressed) {
-        // A veto owns the action completely: the engine is not consulted and no
-        // injection can lift it.
+        // A veto owns the action completely: no injection can lift it. The engine is
+        // still called, for every veto participant, so the press is consumed rather
+        // than piling up and firing all at once when the veto lifts.
         if (action_is_vetoed(ccp, action)) {
+            control_input_filter_check_pressed_unfiltered(ccp, action, nullptr);
             if (just_pressed) {
                 *just_pressed = false;
             }
diff --git a/game_patch/input/key.cpp b/game_patch/input/key.cpp
index 7833e9c05..108b333c8 100644
--- a/game_patch/input/key.cpp
+++ b/game_patch/input/key.cpp
@@ -524,9 +524,11 @@ CodeInjection controls_process_chat_menu_patch{
         const bool chat_menu_numeric_capture_active =
             get_chat_menu_is_active()
             && !rf::console::console_is_visible()
-            && !rf::multi_chat_is_say_visible();
+            && !rf::multi_chat_is_say_visible()
+            && !vote_panel_is_capturing_text();
         const bool waypoint_link_numeric_capture_active =
-            waypoints_utils_link_editor_text_input_active();
+            waypoints_utils_link_editor_text_input_active()
+            && !vote_panel_is_capturing_text();
 
         // Consume top-row number keys for active overlay input modes so they do
         // not trigger gameplay bindings.
diff --git a/game_patch/misc/alpine_options.cpp b/game_patch/misc/alpine_options.cpp
index 8daa01fac..44d08d2f5 100644
--- a/game_patch/misc/alpine_options.cpp
+++ b/game_patch/misc/alpine_options.cpp
@@ -848,12 +848,13 @@ void load_single_af_options_file(const std::string& file_name)
         }
 
         auto meta_it = option_metadata.find(option_name);
+        const bool meta_found = meta_it != option_metadata.end();
 
         // Allow any af_client*.tbl file for options designated to af_client.tbl
-        bool is_af_client_variant = (meta_it->second.filename == "af_client.tbl" &&
-                                     file_name.rfind("af_client", 0) == 0 && file_name.ends_with(".tbl"));
+        const bool is_af_client_variant = (meta_found && meta_it->second.filename == "af_client.tbl" &&
+                                           file_name.rfind("af_client", 0) == 0 && file_name.ends_with(".tbl"));
 
-        if (meta_it != option_metadata.end() &&
+        if (meta_found &&
             (meta_it->second.filename == file_name || is_af_client_variant) &&
             (!rf::is_dedicated_server || meta_it->second.apply_on_server)) {
             
@@ -866,7 +867,7 @@ void load_single_af_options_file(const std::string& file_name)
                 xlog::debug("Option ID {} marked as loaded", static_cast<std::size_t>(metadata.id));
             }
         }
-        else if (meta_it != option_metadata.end()) {
+        else if (meta_found) {
             if (meta_it->second.filename != file_name && !is_af_client_variant) {
                 xlog::warn("Option {} in {} skipped (wrong alpine tbl file)", option_name, file_name);
             }
diff --git a/game_patch/misc/alpine_settings.cpp b/game_patch/misc/alpine_settings.cpp
index 2277939d7..238c78fcb 100644
--- a/game_patch/misc/alpine_settings.cpp
+++ b/game_patch/misc/alpine_settings.cpp
@@ -1625,7 +1625,7 @@ void alpine_player_settings_save(rf::Player* player)
     const std::vector<std::string>& unreadable_saved_votes = saved_votes_unparsed();
     if (!saved_votes.empty() || !unreadable_saved_votes.empty()) {
         file << "\n[SavedVotes]\n";
-        file << "; Format is SavedVote{N}=1|{Name}|{Type}|{Level}|{GameType}|{TeamSize}|{ExtendMinutes}|{Mutators}\n";
+        file << "; Format is SavedVote{N}=2|{Name}|{Type}|{Level}|{GameType}|{TeamSize}|{ExtendMinutes}|{Mutators}|{MutatorsExplicit}\n";
 
         for (size_t i = 0; i < saved_votes.size(); ++i) {
             file << "SavedVote" << i << "=" << saved_vote_encode(saved_votes[i]) << "\n";
diff --git a/game_patch/misc/saved_votes.cpp b/game_patch/misc/saved_votes.cpp
index cb9eaba72..efb98598d 100644
--- a/game_patch/misc/saved_votes.cpp
+++ b/game_patch/misc/saved_votes.cpp
@@ -15,6 +15,7 @@
 #include "alpine_settings.h"
 #include "../multi/multi.h"
 #include "../multi/vote_client.h"
+#include "../rf/level.h"
 
 namespace
 {
@@ -33,12 +34,14 @@ constexpr size_t max_unparsed_lines = 50;
 // ---------------------------------------------------------------------------
 // One-line INI encoding
 //
-//   1|<name>|<type>|<level>|<gametype>|<team_size>|<extend_minutes>|<mutators>
+//   2|<name>|<type>|<level>|<gametype>|<team_size>|<extend_minutes>|<mutators>|<explicit>
 //
 // <mutators> is entries joined by ';', each `name` or `name:opt=Xval,opt=Xval`,
 // where the value's first character types it: b0/b1 bool, i<n> int, f<n> float,
-// c<label> choice. Every free-text field percent-encodes the separators plus any
+// c<label> choice. <explicit> is 0/1: whether <mutators> is the complete set the vote
+// installs. Every free-text field percent-encodes the separators plus any
 // control character, so a level or choice label containing one round-trips.
+// Version 1 is the same line without <explicit>, and still loads.
 // ---------------------------------------------------------------------------
 
 constexpr std::string_view reserved_chars = "%|;:,=";
@@ -228,6 +231,27 @@ const VoteMutatorSchema* find_mutator_schema(const VoteOptionsData& options, std
     return nullptr;
 }
 
+const VoteLevelInfo* find_level_info(const VoteOptionsData& options, std::string_view level)
+{
+    const std::string wanted = normalize_level_filename(level);
+    for (const auto& entry : options.levels) {
+        if (string_iequals(entry.filename, wanted)) {
+            return &entry;
+        }
+    }
+    return nullptr;
+}
+
+const VoteGametypeInfo* find_gametype_info(const VoteOptionsData& options, uint8_t game_type)
+{
+    for (const auto& gametype : options.gametypes) {
+        if (gametype.id == game_type) {
+            return &gametype;
+        }
+    }
+    return nullptr;
+}
+
 const VoteMutatorOptionSchema* find_option_schema(const VoteMutatorSchema& schema,
                                                   const SavedVoteOptionValue& value)
 {
@@ -241,6 +265,42 @@ const VoteMutatorOptionSchema* find_option_schema(const VoteMutatorSchema& schem
     return nullptr;
 }
 
+// The level a Level/Match record is judged and called against. VoteMatch::validate
+// substitutes the running level for an empty name; same here.
+std::string gate_level_for(const SavedVote& vote)
+{
+    if (vote.type == AfVoteType::Match && vote.level.empty()) {
+        return std::string{rf::level.filename.c_str()};
+    }
+    return vote.level;
+}
+
+// The game type a Level/Match record resolves to AND the byte
+// saved_vote_build_params sends for it - one function so the availability answer
+// can only ever be about the bytes that actually go out. A record naming a type
+// keeps it; a record naming none is resolved through the same helpers the live
+// form's pre-selection uses, so a saved call and the equivalent live call are the
+// same packet.
+uint8_t effective_gametype_for(const SavedVote& vote, const VoteOptionsData& options)
+{
+    if (vote.gametype != af_vote_gametype_none) {
+        return vote.gametype;
+    }
+    if (vote.type != AfVoteType::Level && vote.type != AfVoteType::Match) {
+        return af_vote_gametype_none;
+    }
+    // A Match record that follows the running level is the panel's "Current level"
+    // row: it resolves from the type RUNNING, not from that level's configured one.
+    if (vote.type == AfVoteType::Match && vote.level.empty()) {
+        return vote_match_current_level_gametype(options);
+    }
+    const std::string gate_level = gate_level_for(vote);
+    if (!find_level_info(options, gate_level) && !options.base_game_type_present) {
+        return af_vote_gametype_none;
+    }
+    return vote_default_gametype_for_level(options, gate_level);
+}
+
 } // namespace
 
 bool saved_vote_type_is_savable(AfVoteType type)
@@ -338,7 +398,7 @@ const std::vector<std::string>& saved_votes_unparsed()
 
 std::string saved_vote_encode(const SavedVote& vote)
 {
-    std::string out = "1|";
+    std::string out = "2|";
     out += encode_field(vote.name);
     out += '|';
     out += std::format("{}", static_cast<unsigned>(vote.type));
@@ -397,6 +457,8 @@ std::string saved_vote_encode(const SavedVote& vote)
             }
         }
     }
+    out += '|';
+    out += vote.mutators_explicit ? '1' : '0';
     return out;
 }
 
@@ -411,7 +473,10 @@ bool saved_vote_parse(std::string_view encoded, SavedVote& out)
     }
 
     const auto fields = split_view(encoded, '|');
-    if (fields.size() != 8 || fields[0] != "1") {
+    // Version 1: 8 fields. Version 2: the same plus the explicit-mutators field.
+    const bool v1 = fields.size() == 8 && fields[0] == "1";
+    const bool v2 = fields.size() == 9 && fields[0] == "2";
+    if (!v1 && !v2) {
         return false;
     }
 
@@ -526,6 +591,19 @@ bool saved_vote_parse(std::string_view encoded, SavedVote& out)
         }
     }
 
+    if (v2) {
+        unsigned long explicit_raw = 0;
+        if (!parse_uint_field(fields[8], explicit_raw) || explicit_raw > 1) {
+            return false;
+        }
+        vote.mutators_explicit = explicit_raw != 0;
+    }
+    else {
+        // Version 1 predates the field: same fallback the wire gives a call with no
+        // flags byte, plus the gametype term.
+        vote.mutators_explicit = !vote.mutators.empty() || vote.gametype != af_vote_gametype_none;
+    }
+
     // A Level vote with no level could never be called, so it is rejected here
     // rather than being listed as permanently broken.
     if (vote.type == AfVoteType::Level && vote.level.empty()) {
@@ -555,76 +633,97 @@ SavedVoteAvailability saved_vote_check(const SavedVote& vote, const VoteOptionsD
         out.reasons.emplace_back("This vote type is disabled on this server");
     }
 
+    // The game type the server will resolve this vote to, and the byte
+    // saved_vote_build_params sends for it -- the same derivation, so a record that
+    // passes here is a record whose exact packet the server accepts.
+    uint8_t effective_gametype = effective_gametype_for(vote, *options);
+    // Nothing resolved it and the record follows the running level: the byte sent is
+    // none, so the server resolves it from the level running there. Judged against
+    // the type running here, which is the closest this side can get.
+    if (effective_gametype == af_vote_gametype_none && vote.type == AfVoteType::Match
+        && vote.level.empty()) {
+        effective_gametype = static_cast<uint8_t>(rf::multi_get_game_type());
+    }
+
     if (vote.type == AfVoteType::Level || vote.type == AfVoteType::Match) {
-        if (vote.level.empty()) {
+        const bool use_current_level = vote.type == AfVoteType::Match && vote.level.empty();
+        const std::string gate_level = gate_level_for(vote);
+        const VoteLevelInfo* found = find_level_info(*options, gate_level);
+
+        if (gate_level.empty()) {
             if (vote.type == AfVoteType::Level) {
                 out.reasons.emplace_back("No level is saved for this vote");
             }
-            // Match's empty level is the "current level" row: always valid.
+            // Match with no level running yet: nothing to gate against.
         }
         else {
-            const std::string wanted = normalize_level_filename(vote.level);
-            const VoteLevelInfo* found = nullptr;
-            for (const auto& level : options->levels) {
-                if (string_iequals(level.filename, wanted)) {
-                    found = &level;
-                    break;
-                }
-            }
             // A level the blob does not list at all is still allowed: that is
             // exactly what the live form's manual entry does, and the server
             // adjudicates it at call time.
             if (found) {
                 if (!found->allowed_for_vote) {
-                    out.reasons.emplace_back("Level is not on the server's vote list");
+                    out.reasons.emplace_back(use_current_level
+                        ? "Current level is not on the server's vote list"
+                        : "Level is not on the server's vote list");
                 }
-                else if (options->gametype_prefix_restricted) {
-                    const bool matches = vote.gametype == af_vote_gametype_none
-                        ? vote_level_allows_default_gametype(*found)
-                        : vote_level_allows_gametype(*found, vote.gametype);
-                    if (!matches) {
-                        out.reasons.emplace_back("Level is not valid for this game type here");
-                    }
+                else if (options->gametype_prefix_restricted
+                         && !vote_level_allows_gametype(*found, effective_gametype)) {
+                    out.reasons.emplace_back(use_current_level
+                        ? "Current level is not valid for this game type here"
+                        : "Level is not valid for this game type here");
                 }
             }
         }
     }
 
-    if (vote.gametype != af_vote_gametype_none) {
-        const VoteGametypeInfo* found = nullptr;
-        for (const auto& gametype : options->gametypes) {
-            if (gametype.id == vote.gametype) {
-                found = &gametype;
-                break;
-            }
-        }
-        if (!found) {
-            out.reasons.emplace_back("Game type not offered on this server");
-        }
-        else if (vote.type == AfVoteType::Match && !found->is_team_type) {
+    // Only Level and Match put a game type and a mutator set on the wire (see
+    // saved_vote_build_params); an Extend record sends neither, so a stray field on
+    // a hand-edited one must not make it uncallable.
+    const bool sends_rules = vote.type == AfVoteType::Level || vote.type == AfVoteType::Match;
+
+    // Keyed on the SENT type, not the record's own: the blob lists every game type
+    // the server's resolve_vote_gametype accepts, so this is that bound mirrored --
+    // and it has to cover a derived byte too, now that one can be sent.
+    if (sends_rules && effective_gametype != af_vote_gametype_none
+        && !find_gametype_info(*options, effective_gametype)) {
+        out.reasons.emplace_back("Game type not offered on this server");
+    }
+
+    // Gated on the RESOLVED type: VoteMatch::validate judges what will actually apply.
+    if (vote.type == AfVoteType::Match && effective_gametype != af_vote_gametype_none) {
+        const VoteGametypeInfo* found = find_gametype_info(*options, effective_gametype);
+        if (found && !found->is_team_type) {
             out.reasons.emplace_back("Not a team game type");
         }
     }
 
-    for (const auto& mutator : vote.mutators) {
-        const VoteMutatorSchema* schema = find_mutator_schema(*options, mutator.name);
-        if (!schema) {
-            out.reasons.push_back(std::format("Mutator '{}' is not available here", mutator.name));
-            continue;
-        }
-        for (const auto& value : mutator.values) {
-            const VoteMutatorOptionSchema* option = find_option_schema(*schema, value);
-            if (!option) {
-                // One line per mutator: listing every mismatched option of a
-                // mutator that simply changed shape says nothing extra.
+    if (sends_rules) {
+        for (const auto& mutator : vote.mutators) {
+            const VoteMutatorSchema* schema = find_mutator_schema(*options, mutator.name);
+            if (!schema) {
+                out.reasons.push_back(std::format("Mutator '{}' is not available here", mutator.name));
+                continue;
+            }
+            // The gate mutators_build_declarations_from_vote applies at call time.
+            if (!mutator_gametype_mask_allows(schema->valid_gametype_mask, effective_gametype)) {
                 out.reasons.push_back(
-                    std::format("Mutator '{}' has different options here", mutator.name));
-                break;
+                    std::format("Mutator '{}' cannot be used in this game type", mutator.name));
+                continue;
             }
-            if (value.type == MutatorOptionType::Choice
-                && find_choice_index(*option, value.choice_label) < 0) {
-                out.reasons.push_back(std::format("Mutator '{}': choice '{}' not available here",
-                    mutator.name, value.choice_label));
+            for (const auto& value : mutator.values) {
+                const VoteMutatorOptionSchema* option = find_option_schema(*schema, value);
+                if (!option) {
+                    // One line per mutator: listing every mismatched option of a
+                    // mutator that simply changed shape says nothing extra.
+                    out.reasons.push_back(
+                        std::format("Mutator '{}' has different options here", mutator.name));
+                    break;
+                }
+                if (value.type == MutatorOptionType::Choice
+                    && find_choice_index(*option, value.choice_label) < 0) {
+                    out.reasons.push_back(std::format("Mutator '{}': choice '{}' not available here",
+                        mutator.name, value.choice_label));
+                }
             }
         }
     }
@@ -642,7 +741,11 @@ AfVoteCallParams saved_vote_build_params(const SavedVote& vote, const VoteOption
         case AfVoteType::Level:
         case AfVoteType::Match: {
             params.level = vote.level;
-            params.gametype = vote.gametype;
+            // Resolved rather than forwarded: sending the derived type is what makes
+            // saved_vote_check's answer be about the packet that actually goes out,
+            // and it is the same byte the live form submits for the same selection.
+            params.gametype = effective_gametype_for(vote, options);
+            params.mutators_explicit = vote.mutators_explicit;
             if (vote.type == AfVoteType::Match) {
                 params.team_size = static_cast<uint8_t>(std::clamp<int>(vote.team_size, 1, 8));
             }
diff --git a/game_patch/misc/saved_votes.h b/game_patch/misc/saved_votes.h
index 51ad81d5f..f06d11189 100644
--- a/game_patch/misc/saved_votes.h
+++ b/game_patch/misc/saved_votes.h
@@ -37,6 +37,9 @@ struct SavedVote
     uint8_t team_size = 4;
     uint8_t extend_minutes = af_vote_extend_default_minutes;
     std::vector<SavedVoteMutator> mutators;
+    // A record written before this field existed derives it from whether that
+    // record named any mutators or named a game type.
+    bool mutators_explicit = false;
 };
 
 // The only three types worth saving: everything else is either parameterless
diff --git a/game_patch/misc/vote_panel.cpp b/game_patch/misc/vote_panel.cpp
index 7e080add6..19e41e30c 100644
--- a/game_patch/misc/vote_panel.cpp
+++ b/game_patch/misc/vote_panel.cpp
@@ -13,6 +13,7 @@
 #include <common/utils/string-utils.h>
 #include <xlog/xlog.h>
 #include "vote_panel.h"
+#include "alpine_options.h"
 #include "player.h"
 #include "saved_votes.h"
 #include "../hud/hud_internal.h"
@@ -325,8 +326,8 @@ struct PanelOptionValue
     int32_t int_value = 0;
     float float_value = 0.0f;
 
-    // The last int value the panel filled in by itself.
-    std::optional<int32_t> auto_defaulted_int;
+    // Set by an explicit source; the auto-default must then leave the number alone.
+    bool player_owned = false;
 };
 
 struct PanelMutatorSelection
@@ -357,18 +358,24 @@ struct FormState
     std::string level_selection; // level NAME; empty = the "Current level" row
     bool manual_level = false;
     std::string manual_level_name;
-    int gametype_index = 0; // 0 = server default
+    int gametype_index = 0; // index into selectable_gametypes(); the panel always picks a concrete type
     int team_size = 4;
     int extend_minutes = af_vote_extend_default_minutes;
     std::vector<PanelMutatorSelection> mutators;
     int description_mutator = -1;
 
-    // The mutator section starts pre-selected with what the level in context runs
-    // anyway, and is re-derived when that context changes, but only until the
-    // player touches it, after which the form is theirs and is never stomped.
+    // Re-derived whenever its context moves, but only until the player touches it.
     bool mutators_touched = false;
-    std::string mutators_baseline_key;      // level string the pre-selection came from
+    std::string mutators_baseline_key;         // only used on a server too old to push an active set
     uint32_t mutators_baseline_generation = 0; // options generation it came from
+    uint32_t mutators_baseline_revision = 0;   // active-set revision it came from
+
+    // Same model for the game type cycler, un-pinned again by its Reset button.
+    bool gametype_touched = false;
+    std::string gametype_key;
+    bool gametype_key_valid = false;
+    bool gametype_key_match = false;      // the key was resolved for a Match vote
+    uint32_t gametype_key_generation = 0; // options generation the key was resolved against
 
     float level_scroll = 0.0f;
     float kick_scroll = 0.0f;
@@ -451,6 +458,9 @@ struct SavedAvailabilityKey
     uint32_t options_generation = 0;
     bool has_options = false;
     bool server_supported = false;
+    // The Match "current level" row is checked against the running level and type.
+    std::string level;
+    uint8_t gametype = 0;
 
     bool operator==(const SavedAvailabilityKey&) const = default;
 };
@@ -550,7 +560,7 @@ bool ui_hover(const PanelUi& ui, const Rect& r)
 }
 
 // String boxes (level filter, manual level name) edit their bound string live.
-// Numeric boxes (mutator Int/Float options) edit g_text_input_buffer and commit
+// Numeric boxes (mutator Int/Float options, Extend duration) edit g_text_input_buffer and commit
 // on ENTER / click-away / focus loss, or revert on ESC.
 
 // Defined below with the other widget helpers; needed here because the text
@@ -559,6 +569,7 @@ Rect ui_draw_rect(const PanelUi& ui, const Rect& r);
 
 constexpr uint32_t kTextInputLevelFilter = 1;
 constexpr uint32_t kTextInputManualLevel = 2;
+constexpr uint32_t kTextInputExtendMinutes = 3;
 
 uint32_t text_input_id_for_option(uint8_t mutator_id, uint8_t option_id)
 {
@@ -571,6 +582,35 @@ bool g_text_input_seen_this_pass = false;
 // Numeric edit buffer; the bound value is only written on commit.
 std::string g_text_input_buffer;
 
+struct TextInputTarget
+{
+    std::string* text = nullptr;
+    size_t max_len = 0;
+    bool (*allow_char)(char) = nullptr;
+};
+TextInputTarget g_text_input_target;
+bool g_text_input_changed = false;
+
+// One keystroke the callback captured. The callback runs BETWEEN a frame's two passes,
+// so keys are recorded in order and applied at the top of the next hit-test pass.
+struct PendingTextKey
+{
+    enum class Kind : uint8_t
+    {
+        Char,
+        Backspace,
+        Escape,
+        Enter,
+    };
+
+    Kind kind = Kind::Char;
+    char c = 0;
+};
+
+std::vector<PendingTextKey> g_text_input_pending;
+// A single frame cannot legitimately produce more than the key ring holds.
+constexpr size_t TEXT_INPUT_PENDING_MAX = 64;
+
 bool text_input_char_filename(char c)
 {
     return std::isalnum(static_cast<unsigned char>(c)) != 0
@@ -582,6 +622,11 @@ bool text_input_char_numeric(char c)
     return std::isdigit(static_cast<unsigned char>(c)) != 0 || c == '-' || c == '.';
 }
 
+bool text_input_char_digit(char c)
+{
+    return std::isdigit(static_cast<unsigned char>(c)) != 0;
+}
+
 // Parse-and-write for a numeric box. Re-validated before application.
 void commit_numeric_text_input()
 {
@@ -605,13 +650,17 @@ void commit_numeric_text_input()
 
     PanelOptionValue& value = g_form.mutators[g_popup_mutator].options[g_popup_option];
     try {
+        // Claimed here too: a baseline overlay can run earlier in the same pass and
+        // reset ownership.
         if (schema.options[g_popup_option].type == MutatorOptionType::Int) {
             value.int_value = std::stoi(g_text_input_buffer);
+            value.player_owned = true;
         }
         else {
             const float parsed = std::stof(g_text_input_buffer);
             if (std::isfinite(parsed)) {
                 value.float_value = parsed;
+                value.player_owned = true;
             }
             else {
                 xlog::info("vote panel: non-finite option input '{}' ignored", g_text_input_buffer);
@@ -623,13 +672,34 @@ void commit_numeric_text_input()
     }
 }
 
+// Parse-and-write for Extend's duration box. Clamped here, exactly where the
+// popup this replaced clamped.
+void commit_extend_minutes_text_input()
+{
+    try {
+        g_form.extend_minutes = std::clamp(std::stoi(g_text_input_buffer),
+            static_cast<int>(af_vote_extend_min_minutes),
+            static_cast<int>(af_vote_extend_max_minutes));
+    }
+    catch (const std::exception& e) {
+        // Empty or out of int range: keep whatever was already selected.
+        xlog::info("vote panel: invalid extend duration '{}', reason: {}", g_text_input_buffer,
+            e.what());
+    }
+}
+
 // End the focused edit. String boxes edit live, so for them this only drops focus.
 void text_input_release_focus(bool commit)
 {
     if (g_text_input_focus == 0) {
         return;
     }
-    if (g_popup_mutator >= 0) { // a numeric box owns the write-back target
+    if (g_text_input_focus == kTextInputExtendMinutes) {
+        if (commit) {
+            commit_extend_minutes_text_input();
+        }
+    }
+    else if (g_popup_mutator >= 0) { // a numeric box owns the write-back target
         if (commit) {
             commit_numeric_text_input();
         }
@@ -637,11 +707,14 @@ void text_input_release_focus(bool commit)
     }
     g_text_input_focus = 0;
     g_text_input_buffer.clear();
+    g_text_input_target = TextInputTarget{};
+    g_text_input_changed = false;
+    g_text_input_pending.clear();
 }
 
 struct TextInputResult
 {
-    bool changed = false;      // `text` was edited this pass
+    bool changed = false;      // `text` was edited since the previous pass
     bool gained_focus = false; // this click focused the box; caller seeds state
 };
 
@@ -653,6 +726,11 @@ TextInputResult ui_text_input(PanelUi& ui, const Rect& r, uint32_t id, std::stri
     const bool focused_at_entry = g_text_input_focus == id;
 
     if (!ui.draw) {
+        // Focus on a greyed box strands the control veto with nothing to type into.
+        if (focused_at_entry && !enabled) {
+            text_input_release_focus(false);
+            return res;
+        }
         if (focused_at_entry) {
             g_text_input_seen_this_pass = true;
         }
@@ -669,39 +747,10 @@ TextInputResult ui_text_input(PanelUi& ui, const Rect& r, uint32_t id, std::stri
                 text_input_release_focus(true);
             }
         }
-        // Pump only when the box already held focus at entry: the pass that
-        // grants focus returns first so the caller can seed the edit buffer.
         if (focused_at_entry && g_text_input_focus == id) {
-            for (;;) {
-                const rf::Key key = rf::key_get();
-                if (key == rf::KEY_NONE) {
-                    break;
-                }
-                const int code = key & rf::KEY_MASK;
-                if (code == rf::KEY_ESC) {
-                    text_input_release_focus(false);
-                    break;
-                }
-                if (code == rf::KEY_ENTER || code == rf::KEY_PADENTER) {
-                    text_input_release_focus(true);
-                    break;
-                }
-                if (code == rf::KEY_BACKSP) {
-                    if (!text.empty()) {
-                        text.pop_back();
-                        res.changed = true;
-                    }
-                    continue;
-                }
-                const int ascii = rf::key_to_ascii(static_cast<int16_t>(key));
-                if (ascii > 0 && ascii < 0x80 && ascii != 0xFF) {
-                    const char c = static_cast<char>(ascii);
-                    if (allow_char(c) && text.size() < max_len) {
-                        text.push_back(c);
-                        res.changed = true;
-                    }
-                }
-            }
+            g_text_input_target = TextInputTarget{&text, max_len, allow_char};
+            res.changed = g_text_input_changed;
+            g_text_input_changed = false;
         }
         return res;
     }
@@ -1176,12 +1225,15 @@ uint32_t schema_fingerprint(const VoteOptionsData& options)
 
 std::string selected_level();
 
-const std::vector<VoteMutatorDecl>& resolve_baseline(const VoteOptionsData& options, const std::string& level_string)
+std::vector<VoteMutatorDecl> resolve_baseline(const VoteOptionsData& options, const std::string& level_string)
 {
-    // Empty is Match's "Current level" row (and the state right after a rebuild),
-    // which resolves against whatever is running locally. Normalized the same way
-    // the server normalizes a voted level name, so both resolve the same file; a
-    // no-op for anything picked out of the level list, which already carries it.
+    // What the session runs now, so an untouched form reproduces it. The level only
+    // matters on a server too old to push an active set.
+    if (const std::vector<VoteMutatorDecl>* active = vote_active_mutators_get()) {
+        return *active;
+    }
+
+    // Empty is Match's "Current level" row. Normalized like a voted level name.
     const std::string wanted = normalize_level_filename(level_string.empty()
         ? std::string_view{rf::level.filename.c_str()}
         : std::string_view{level_string});
@@ -1195,6 +1247,29 @@ const std::vector<VoteMutatorDecl>& resolve_baseline(const VoteOptionsData& opti
     return options.base_mutator_decls;
 }
 
+// Pin the context so the pre-selection stops re-deriving over the form.
+void pin_mutator_baseline_context()
+{
+    g_form.mutators_baseline_key = selected_level();
+    g_form.mutators_baseline_generation = vote_options_loaded_generation();
+    g_form.mutators_baseline_revision = vote_active_mutators_revision();
+}
+
+void pin_gametype_context(bool is_match)
+{
+    g_form.gametype_key = selected_level();
+    g_form.gametype_key_match = is_match;
+    g_form.gametype_key_generation = vote_options_loaded_generation();
+    g_form.gametype_key_valid = true;
+}
+
+void reset_gametype_selection()
+{
+    g_form.gametype_touched = false;
+    g_form.gametype_key_valid = false;
+    g_form.gametype_index = 0;
+}
+
 // Every mutator deselected and back on the schema (factory) defaults. Shared by
 // apply_baseline and the saved-vote load, which both need a clean slate first.
 void reset_mutators_to_defaults(const VoteOptionsData& options)
@@ -1212,6 +1287,7 @@ void reset_mutators_to_defaults(const VoteOptionsData& options)
             value.choice_index = option.default_choice;
             value.int_value = option.default_int;
             value.float_value = option.default_float;
+            value.player_owned = false;
         }
     }
 }
@@ -1263,9 +1339,11 @@ void apply_baseline(const VoteOptionsData& options, const std::vector<VoteMutato
                         break;
                     case MutatorOptionType::Int:
                         value.int_value = declared.int_value;
+                        value.player_owned = true;
                         break;
                     case MutatorOptionType::Float:
                         value.float_value = declared.float_value;
+                        value.player_owned = true;
                         break;
                     default:
                         // String has no widget and no slot in PanelOptionValue, so
@@ -1290,7 +1368,6 @@ void build_form(const VoteOptionsData& options)
     g_form.level_selection.clear();
     g_form.manual_level = false;
     g_form.manual_level_name.clear();
-    g_form.gametype_index = 0;
     g_form.team_size = 4;
     g_form.extend_minutes = af_vote_extend_default_minutes;
     g_form.description_mutator = -1;
@@ -1319,8 +1396,8 @@ void build_form(const VoteOptionsData& options)
     // current level; do_form re-derives it as soon as that changes.
     apply_baseline(options, resolve_baseline(options, selected_level()));
     g_form.mutators_touched = false;
-    g_form.mutators_baseline_key = selected_level();
-    g_form.mutators_baseline_generation = vote_options_loaded_generation();
+    pin_mutator_baseline_context();
+    reset_gametype_selection();
 }
 
 void ensure_form(const VoteOptionsData& options)
@@ -1333,8 +1410,6 @@ void ensure_form(const VoteOptionsData& options)
     }
 }
 
-// The level string sent on the wire. `allow_current` (Match) maps the leading
-// "Current level" row to the empty string the server reads as "keep the level".
 // Case-insensitive ordering for the level list.
 bool level_name_less(const std::string& a, const std::string& b)
 {
@@ -1342,45 +1417,101 @@ bool level_name_less(const std::string& a, const std::string& b)
         [](unsigned char l, unsigned char r) { return std::tolower(l) < std::tolower(r); });
 }
 
+// The level string sent on the wire. Tracked by NAME so a re-sort or blob refresh
+// cannot desync it; empty is Match's "keep the current level".
 std::string selected_level()
 {
     if (g_form.manual_level) {
         return g_form.manual_level_name;
     }
-    // Stored by name, so the display sort (and any blob refresh) cannot desync
-    // it. Empty is exactly what the wire wants for Match's "current level".
     return g_form.level_selection;
 }
 
-uint8_t selected_gametype(const VoteOptionsData& options, bool team_only)
+// "none" only when the server offered nothing to pick, leaving it to resolve.
+uint8_t selected_gametype(const std::vector<const VoteGametypeInfo*>& gametypes)
 {
-    if (g_form.gametype_index <= 0) {
-        return af_vote_gametype_none;
-    }
-    const auto gametypes = selectable_gametypes(options, team_only);
-    const int index = g_form.gametype_index - 1;
-    if (index < 0 || index >= static_cast<int>(gametypes.size())) {
+    if (g_form.gametype_index < 0 || g_form.gametype_index >= static_cast<int>(gametypes.size())) {
         return af_vote_gametype_none;
     }
-    return gametypes[index]->id;
+    return gametypes[g_form.gametype_index]->id;
+}
+
+uint8_t selected_gametype(const VoteOptionsData& options, bool team_only)
+{
+    return selected_gametype(selectable_gametypes(options, team_only));
 }
 
 // The game type the vote would actually run under.
-uint8_t effective_gametype(const VoteOptionsData& options, bool team_only)
+uint8_t effective_gametype(const VoteOptionsData& options,
+                           const std::vector<const VoteGametypeInfo*>& gametypes)
 {
-    const uint8_t chosen = selected_gametype(options, team_only);
+    const uint8_t chosen = selected_gametype(gametypes);
     if (chosen != af_vote_gametype_none) {
         return chosen;
     }
-    const std::string level = selected_level();
-    if (!level.empty()) {
-        for (const auto& entry : options.levels) {
-            if (string_iequals(entry.filename, level)) {
-                return entry.natural_gametype;
-            }
+    return vote_default_gametype_for_level(options, selected_level());
+}
+
+uint8_t effective_gametype(const VoteOptionsData& options, bool team_only)
+{
+    return effective_gametype(options, selectable_gametypes(options, team_only));
+}
+
+// The game type a level selection pre-selects. Match's "Current level" row (an
+// empty name) goes through the shared derivation, so a saved record of that row
+// resolves to the same byte this form submits.
+uint8_t form_default_gametype(const VoteOptionsData& options, bool is_match, const std::string& level)
+{
+    if (is_match && level.empty()) {
+        return vote_match_current_level_gametype(options);
+    }
+    return vote_default_gametype_for_level(options, level);
+}
+
+int gametype_index_in(const std::vector<const VoteGametypeInfo*>& gametypes, uint8_t game_type)
+{
+    for (size_t i = 0; i < gametypes.size(); ++i) {
+        if (gametypes[i]->id == game_type) {
+            return static_cast<int>(i);
+        }
+    }
+    return -1;
+}
+
+// Cycler index of `game_type`; when this vote does not offer it, TeamDM for DM, else
+// `current_index` held rather than moved under a player who did not ask.
+int gametype_cycler_index(const std::vector<const VoteGametypeInfo*>& gametypes, uint8_t game_type,
+                          int current_index)
+{
+    if (const int index = gametype_index_in(gametypes, game_type); index >= 0) {
+        return index;
+    }
+    if (game_type == static_cast<uint8_t>(rf::NG_TYPE_DM)) {
+        const int team_dm = gametype_index_in(gametypes, static_cast<uint8_t>(rf::NG_TYPE_TEAMDM));
+        if (team_dm >= 0) {
+            return team_dm;
         }
     }
-    return static_cast<uint8_t>(rf::multi_get_game_type());
+    const int count = static_cast<int>(gametypes.size());
+    return count > 0 ? std::clamp(current_index, 0, count - 1) : 0;
+}
+
+int gametype_cycler_index(const VoteOptionsData& options, bool team_only, uint8_t game_type, int current_index)
+{
+    return gametype_cycler_index(selectable_gametypes(options, team_only), game_type, current_index);
+}
+
+int gametype_cycler_width(const std::vector<const VoteGametypeInfo*>& gametypes, int font, int max_w)
+{
+    int widest = 0;
+    for (const VoteGametypeInfo* gametype : gametypes) {
+        const char* short_name = gametype_short_name(gametype->id);
+        const std::string_view text =
+            short_name ? std::string_view{short_name} : std::string_view{gametype->name};
+        widest = std::max(widest, rf::gr::get_string_size(text, font).first);
+    }
+    const int want = widest + 2 * ui_cycler_arrow_width() + std::max(6, scaled(12.0f));
+    return std::max(2 * ui_cycler_arrow_width(), std::min(want, max_w));
 }
 
 // A mutator that can't be used in this game type is shown greyed out.
@@ -1391,10 +1522,7 @@ bool mutator_offered(const VoteMutatorSchema& schema, uint8_t game_type)
 
 // Score Limit Override defaults to the limit the chosen game type already runs, so
 // enabling it without touching the number changes nothing. Each game type keeps its
-// own limit and the type is picked live here, so the default has to follow the
-// cycler instead of being fixed when the form is built.
-// Stops as soon as the player edits the field: the value is only replaced while it
-// still matches whatever the panel last put there.
+// own limit, so the default follows the cycler rather than being fixed at form build.
 void sync_score_limit_default(const VoteOptionsData& options, uint8_t game_type)
 {
     const VoteGametypeInfo* gametype = nullptr;
@@ -1404,8 +1532,6 @@ void sync_score_limit_default(const VoteOptionsData& options, uint8_t game_type)
             break;
         }
     }
-    // 0 means the type has no score limit, or the server predates the field.
-    // Either way there is nothing better to offer than the schema default.
     if (!gametype || gametype->score_limit <= 0) {
         return;
     }
@@ -1420,11 +1546,10 @@ void sync_score_limit_default(const VoteOptionsData& options, uint8_t game_type)
                 continue;
             }
             PanelOptionValue& value = g_form.mutators[i].options[o];
-            if (value.auto_defaulted_int && value.int_value != *value.auto_defaulted_int) {
-                return; // the player owns this number now
+            if (value.player_owned) {
+                return; // an explicit source owns this number
             }
             value.int_value = gametype->score_limit;
-            value.auto_defaulted_int = gametype->score_limit;
             return;
         }
         return;
@@ -1460,28 +1585,6 @@ std::vector<VoteMutatorInput> build_mutator_inputs(const VoteOptionsData& option
     return out;
 }
 
-// ---------------------------------------------------------------------------
-// Popup text input (stock RF popup; gameseq_process drives it globally, so it
-// works over the gameplay overlay -- see rf::ui::popup_is_active, which is what
-// suppresses our own input handling while it is up)
-// ---------------------------------------------------------------------------
-
-// Extend's duration entry.
-void extend_minutes_popup_callback()
-{
-    char buffer[32] = "";
-    rf::ui::popup_get_input(buffer, sizeof(buffer));
-    try {
-        g_form.extend_minutes = std::clamp(std::stoi(buffer),
-            static_cast<int>(af_vote_extend_min_minutes),
-            static_cast<int>(af_vote_extend_max_minutes));
-    }
-    catch (const std::exception& e) {
-        // Non-numeric or out of int range: keep whatever was already selected.
-        xlog::info("vote panel: invalid extend duration '{}', reason: {}", buffer, e.what());
-    }
-}
-
 // ---------------------------------------------------------------------------
 // Panel content
 // ---------------------------------------------------------------------------
@@ -1660,19 +1763,12 @@ void load_saved_vote_into_form(const SavedVote& vote, const VoteOptionsData& opt
     if (vote.type == AfVoteType::Level || vote.type == AfVoteType::Match) {
         const bool is_match = vote.type == AfVoteType::Match;
 
-        // Resolved BEFORE the level: the level list is filtered against whichever
-        // game type ends up selected here, and that is not always the saved one (a
-        // game type this server does not offer falls back to "Default").
-        g_form.gametype_index = 0; // "Default"
-        if (vote.gametype != af_vote_gametype_none) {
-            const auto gametypes = selectable_gametypes(options, is_match);
-            for (size_t i = 0; i < gametypes.size(); ++i) {
-                if (gametypes[i]->id == vote.gametype) {
-                    g_form.gametype_index = static_cast<int>(i) + 1;
-                    break;
-                }
-            }
-        }
+        // Resolved BEFORE the level: the list is filtered by whichever type lands here.
+        const uint8_t wanted_gametype = vote.gametype != af_vote_gametype_none
+            ? vote.gametype
+            : form_default_gametype(options, is_match, vote.level);
+        g_form.gametype_index =
+            gametype_cycler_index(options, is_match, wanted_gametype, g_form.gametype_index);
         // Exactly what do_form hands do_level_column.
         const uint8_t effective_gametype = selected_gametype(options, is_match);
 
@@ -1758,9 +1854,11 @@ void load_saved_vote_into_form(const SavedVote& vote, const VoteOptionsData& opt
                             break;
                         case MutatorOptionType::Int:
                             selection.options[o].int_value = value.int_value;
+                            selection.options[o].player_owned = true;
                             break;
                         case MutatorOptionType::Float:
                             selection.options[o].float_value = value.float_value;
+                            selection.options[o].player_owned = true;
                             break;
                         case MutatorOptionType::Choice:
                             for (size_t c = 0; c < option.choices.size(); ++c) {
@@ -1781,10 +1879,14 @@ void load_saved_vote_into_form(const SavedVote& vote, const VoteOptionsData& opt
         // The loaded values are the player's from here on, so the baseline logic must
         // never re-derive over them: mark them touched and pin its context to now.
         g_form.mutators_touched = true;
-        g_form.mutators_baseline_key = selected_level();
-        g_form.mutators_baseline_generation = vote_options_loaded_generation();
+        pin_mutator_baseline_context();
         g_form.mutator_scroll = 0.0f;
     }
+    // Same for the game type, so the level it just resolved cannot re-derive over it.
+    if (vote.type == AfVoteType::Level || vote.type == AfVoteType::Match) {
+        g_form.gametype_touched = true;
+        pin_gametype_context(vote.type == AfVoteType::Match);
+    }
     g_level_cache.sel_valid = false;
 }
 
@@ -1965,8 +2067,9 @@ void do_saved_preview(PanelUi& ui, const Layout& lo, const Rect& pane, const Vot
         index = g_saved_selected;
     }
 
-    const int btn_h = lo.row_h;
-    const int btn_w = std::min(pane.w, std::max(scaled(120.0f), lo.row_h * 4));
+    // EDIT is the saved tab's only action, so it is sized like the footer buttons.
+    const int btn_h = std::max(lo.row_h, scaled(40.0f));
+    const int btn_w = std::min(pane.w, std::max(scaled(120.0f), btn_h * 4));
     const Rect edit{pane.x, pane.y + pane.h - btn_h, btn_w, btn_h};
     const int body_bottom = edit.y - lo.gap;
 
@@ -2025,7 +2128,9 @@ void do_saved_tab(PanelUi& ui, const Layout& lo, const Rect& content, const Vote
         const auto& store = saved_votes_get();
         const SavedAvailabilityKey key{true, saved_votes_revision(),
                                        vote_options_loaded_generation(), options != nullptr,
-                                       mode != PanelMode::NotSupported};
+                                       mode != PanelMode::NotSupported,
+                                       rf::level.filename.c_str(),
+                                       static_cast<uint8_t>(rf::multi_get_game_type())};
         if (g_saved_availability_key != key) {
             g_saved_availability_key = key;
             g_saved_availability.clear();
@@ -2057,8 +2162,9 @@ void do_saved_tab(PanelUi& ui, const Layout& lo, const Rect& content, const Vote
 }
 
 // Mirrors send_vote_from_form's validation so the button can be greyed out
-// instead of silently doing nothing when pressed.
-bool vote_form_is_sendable(const VoteOptionsData& options)
+// instead of silently doing nothing when pressed. `for_save` drops the checks that
+// only apply to calling it here and now; saved_vote_check judges a stored record.
+bool vote_form_is_sendable(const VoteOptionsData& options, bool for_save = false)
 {
     const auto tabs = enabled_vote_tabs();
     const VoteTab* tab = selected_tab(tabs);
@@ -2076,12 +2182,30 @@ bool vote_form_is_sendable(const VoteOptionsData& options)
             // Empty means the list had nothing to offer for this game type, or
             // manual entry is on with nothing typed into it yet.
             return !selected_level().empty();
+        case AfVoteType::Match: {
+            // A named level is left to the server; VoteMatch::validate gates the running
+            // level for the empty one, so that case is judged here.
+            if (!selected_level().empty() || for_save) {
+                return true;
+            }
+            const std::string running = normalize_level_filename(rf::level.filename.c_str());
+            for (const auto& entry : options.levels) {
+                if (!string_iequals(entry.filename, running)) {
+                    continue;
+                }
+                if (!entry.allowed_for_vote) {
+                    return false;
+                }
+                return !options.gametype_prefix_restricted
+                    || vote_level_allows_gametype(entry, effective_gametype(options, true));
+            }
+            return true; // not listed: the server adjudicates, like manual entry
+        }
         case AfVoteType::Extend:
             return true;
         default:
-            return true; // Match falls back to the current level; rest are parameterless
+            return true; // parameterless
     }
-    (void)options;
 }
 
 void send_vote_from_form(const VoteOptionsData& options)
@@ -2112,6 +2236,7 @@ void send_vote_from_form(const VoteOptionsData& options)
             }
             params.gametype = selected_gametype(options, false);
             params.mutators = build_mutator_inputs(options, effective_gametype(options, false));
+            params.mutators_explicit = true;
             break;
         }
         case AfVoteType::Match: {
@@ -2119,6 +2244,7 @@ void send_vote_from_form(const VoteOptionsData& options)
             params.level = selected_level();
             params.gametype = selected_gametype(options, true);
             params.mutators = build_mutator_inputs(options, effective_gametype(options, true));
+            params.mutators_explicit = true;
             break;
         }
         case AfVoteType::Extend:
@@ -2143,17 +2269,6 @@ void send_vote_from_form(const VoteOptionsData& options)
     vote_panel_close();
 }
 
-// Calling a saved vote: the names it stores are resolved against the current
-// schema here, which is only sound because saved_vote_check has already refused
-// anything that does not resolve exactly.
-void send_saved_vote(const SavedVote& vote, const VoteOptionsData& options)
-{
-    af_send_vote_call(saved_vote_build_params(vote, options));
-
-    play_click_sound();
-    vote_panel_close();
-}
-
 // Enabled mutators as names/labels rather than the schema's ids, so the entry
 // stays meaningful on a server whose blob numbers them differently.
 std::vector<SavedVoteMutator> build_saved_mutators(const VoteOptionsData& options, uint8_t game_type)
@@ -2261,6 +2376,7 @@ void begin_save_from_form(const VoteOptionsData& options)
             vote.team_size = static_cast<uint8_t>(std::clamp(g_form.team_size, 1, 8));
         }
         vote.mutators = build_saved_mutators(options, effective_gametype(options, is_match));
+        vote.mutators_explicit = true;
     }
 
     // Snapshotted here, not in the callback: the popup returns later and a blob
@@ -2332,6 +2448,10 @@ void do_mutator_rows(PanelUi& ui, const Layout& lo, const VoteOptionsData& optio
             const Rect row{view.x, y, view.w, lo.row_h};
             // Hovering still describes an unavailable mutator.
             if (!ui.draw && ui_hover(ui, row)) {
+                // A toggle pins its description until the next hover.
+                if (g_form.description_mutator != static_cast<int>(i)) {
+                    g_description_pinned = false;
+                }
                 g_form.description_mutator = static_cast<int>(i);
                 g_hovered_mutator_this_pass = true;
             }
@@ -2433,6 +2553,7 @@ void do_mutator_rows(PanelUi& ui, const Layout& lo, const VoteOptionsData& optio
                         // Marked on focus rather than on commit: the box owns the
                         // value from here, and it must not be re-derived underneath.
                         g_form.mutators_touched = true;
+                        value.player_owned = true;
                         play_click_sound();
                     }
                     break;
@@ -2513,7 +2634,7 @@ void do_mutator_scroll_region(PanelUi& ui, const Layout& lo, const VoteOptionsDa
 }
 
 void do_level_column(PanelUi& ui, const Layout& lo, const VoteOptionsData& options, const Rect& col,
-                     bool allow_current, uint8_t gametype)
+                     bool is_match, uint8_t gametype)
 {
     const int header_h = rf::gr::get_font_height(lo.font);
     int y = col.y;
@@ -2564,6 +2685,10 @@ void do_level_column(PanelUi& ui, const Layout& lo, const VoteOptionsData& optio
     // Read after the checkbox so a toggle takes effect in the same pass.
     const bool filter_active = options.gametype_prefix_restricted || g_filter_gametype_local;
 
+    // With the filter off the type is not consulted, so keying the cache on it would
+    // rebuild an identical list.
+    const uint8_t filter_gametype = filter_active ? gametype : af_vote_gametype_none;
+
     // Rebuild the display rows only when an input changed. allowed_for_vote is an
     // independent axis from the gametype mask: it is applied ALWAYS, because a
     // level the server vote_level allow-list refuses is rejected whatever game
@@ -2572,12 +2697,12 @@ void do_level_column(PanelUi& ui, const Layout& lo, const VoteOptionsData& optio
     LevelListCache& cache = g_level_cache;
     if (!cache.valid || cache.levels_fp != levels_fp || cache.filter_active != filter_active
         || cache.name_filter != g_level_filter_text
-        || cache.gametype != gametype || cache.allow_current != allow_current) {
+        || cache.gametype != filter_gametype || cache.allow_current != is_match) {
         cache.levels_fp = levels_fp;
         cache.filter_active = filter_active;
         cache.name_filter = g_level_filter_text;
-        cache.gametype = gametype;
-        cache.allow_current = allow_current;
+        cache.gametype = filter_gametype;
+        cache.allow_current = is_match;
         cache.gametype_hidden = 0;
         cache.not_allowed_hidden = 0;
         cache.name_filter_hidden = 0;
@@ -2591,9 +2716,9 @@ void do_level_column(PanelUi& ui, const Layout& lo, const VoteOptionsData& optio
                 continue;
             }
             if (filter_active) {
-                const bool matches = gametype == af_vote_gametype_none
+                const bool matches = filter_gametype == af_vote_gametype_none
                     ? vote_level_allows_default_gametype(level)
-                    : vote_level_allows_gametype(level, gametype);
+                    : vote_level_allows_gametype(level, filter_gametype);
                 if (!matches) {
                     ++cache.gametype_hidden;
                     continue;
@@ -2620,14 +2745,14 @@ void do_level_column(PanelUi& ui, const Layout& lo, const VoteOptionsData& optio
 
         cache.items.clear();
         cache.items.reserve(levels.size() + 1);
-        if (allow_current) {
+        if (is_match) {
             // Pinned and always visible; the server adjudicates it at call time.
             cache.items.emplace_back("Current level");
         }
         for (auto& level : levels) {
             cache.items.push_back(std::move(level));
         }
-        cache.first_level_row = allow_current ? 1 : 0;
+        cache.first_level_row = is_match ? 1 : 0;
         cache.valid = true;
     }
 
@@ -2654,7 +2779,7 @@ void do_level_column(PanelUi& ui, const Layout& lo, const VoteOptionsData& optio
     // normalizes a voted name, so both resolve the same file), else the top
     // entry. The list is scrolled to whichever that lands on, since a default
     // sitting off-screen reads as no selection at all.
-    if (!allow_current && g_form.level_selection.empty() && level_row_count > 0) {
+    if (!is_match && g_form.level_selection.empty() && level_row_count > 0) {
         const std::string current =
             normalize_level_filename(std::string_view{rf::level.filename.c_str()});
         size_t row = static_cast<size_t>(cache.first_level_row);
@@ -2680,7 +2805,7 @@ void do_level_column(PanelUi& ui, const Layout& lo, const VoteOptionsData& optio
         cache.sel_row = -1;
         if (!g_form.manual_level) {
             if (g_form.level_selection.empty()) {
-                cache.sel_row = allow_current ? 0 : -1;
+                cache.sel_row = is_match ? 0 : -1;
             }
             else {
                 for (size_t i = cache.first_level_row; i < cache.items.size(); ++i) {
@@ -2720,7 +2845,7 @@ void do_level_column(PanelUi& ui, const Layout& lo, const VoteOptionsData& optio
         g_level_scroll_to_selection = false;
     }
 
-    if (!allow_current && level_row_count == 0) {
+    if (!is_match && level_row_count == 0) {
         // Nothing votable for this game type. Manual entry stays available and
         // unfiltered; CALL VOTE stays inert because the selection is empty.
         if (ui.draw) {
@@ -2744,7 +2869,7 @@ void do_level_column(PanelUi& ui, const Layout& lo, const VoteOptionsData& optio
             ui_listbox(ui, list, cache.items, cache.sel_row, g_form.level_scroll, lo.font);
         if (clicked >= 0) {
             g_form.level_selection =
-                (allow_current && clicked == 0) ? std::string{} : cache.items[clicked];
+                (is_match && clicked == 0) ? std::string{} : cache.items[clicked];
             g_form.manual_level = false;
             cache.sel_valid = false;
             play_click_sound();
@@ -2850,6 +2975,9 @@ int do_tab_row(PanelUi& ui, const Layout& lo, const std::vector<VoteTab>& tabs)
         if (ui_button(ui, btn, tabs[i].label, lo.font, true, active)) {
             if (!active) {
                 g_form.on_saved_tab = false;
+                if (g_form.type_index != i) {
+                    reset_gametype_selection();
+                }
                 g_form.type_index = i;
                 g_form.mutator_scroll = 0.0f; // the section is rebuilt for the new type
             }
@@ -2912,16 +3040,18 @@ void do_rotation_form(PanelUi& ui, const Layout& lo, const VoteOptionsData& opti
 void do_form(PanelUi& ui, const Layout& lo, const VoteOptionsData& options,
              const std::vector<VoteTab>& tabs, int content_y)
 {
-    // Re-derive the mutator pre-selection whenever its context moves.
-    {
+    // The level key only matters on a server too old to push an active set.
+    if (!g_form.mutators_touched) {
         std::string baseline_key = selected_level();
         const uint32_t generation = vote_options_loaded_generation();
-        if (!g_form.mutators_touched
-            && (baseline_key != g_form.mutators_baseline_key
-                || generation != g_form.mutators_baseline_generation)) {
+        const uint32_t revision = vote_active_mutators_revision();
+        if (baseline_key != g_form.mutators_baseline_key
+            || generation != g_form.mutators_baseline_generation
+            || revision != g_form.mutators_baseline_revision) {
             apply_baseline(options, resolve_baseline(options, baseline_key));
             g_form.mutators_baseline_key = std::move(baseline_key);
             g_form.mutators_baseline_generation = generation;
+            g_form.mutators_baseline_revision = revision;
         }
     }
 
@@ -2932,11 +3062,12 @@ void do_form(PanelUi& ui, const Layout& lo, const VoteOptionsData& options,
 
     int y = content_y;
 
-    const VoteTab& tab = tabs[g_form.type_index];
-    const VoteTypeInfo* selected = tab_selected_type(tab);
+    const VoteTab* tab_ptr = selected_tab(tabs);
+    const VoteTypeInfo* selected = tab_ptr ? tab_selected_type(*tab_ptr) : nullptr;
     if (!selected) {
         return;
     }
+    const VoteTab& tab = *tab_ptr;
     const AfVoteType type = selected->type;
     const int body_bottom = lo.cy + lo.ch;
 
@@ -2996,9 +3127,14 @@ void do_form(PanelUi& ui, const Layout& lo, const VoteOptionsData& options,
                 lo.font);
         }
         const Rect value_rect{lo.cx + label_w, y, value_w, lo.row_h};
-        const std::string value_text = std::format("{}", g_form.extend_minutes);
-        if (ui_button(ui, value_rect, value_text.c_str(), lo.font)) {
-            rf::ui::popup_message("Minutes to extend (1-60):", "", extend_minutes_popup_callback, 1);
+        // Inline edit, same idiom as the mutator Int/Float boxes.
+        const bool editing = g_text_input_focus == kTextInputExtendMinutes;
+        std::string display = std::format("{}", g_form.extend_minutes);
+        const TextInputResult res = ui_text_input(ui, value_rect, kTextInputExtendMinutes,
+            editing ? g_text_input_buffer : display, 2, text_input_char_digit, nullptr, lo.font);
+        if (res.gained_focus) {
+            g_text_input_buffer = std::format("{}", g_form.extend_minutes);
+            play_click_sound();
         }
         y += lo.row_h + lo.gap * 2;
 
@@ -3015,6 +3151,30 @@ void do_form(PanelUi& ui, const Layout& lo, const VoteOptionsData& options,
     }
 
     const bool is_match = type == AfVoteType::Match;
+
+    // Pre-select the game type the picked level runs under, until the player moves the
+    // cycler. Hit-test pass only: the level list below is filtered by it, so moving it
+    // between a frame's two passes would draw a list nothing hit-tested.
+    if (!ui.draw && !g_form.gametype_touched) {
+        const std::string key = selected_level();
+        // Keyed on the generation too: a blob refresh can change what a level resolves
+        // to, and an untouched cycler has to follow it.
+        if (!g_form.gametype_key_valid || key != g_form.gametype_key
+            || is_match != g_form.gametype_key_match
+            || g_form.gametype_key_generation != vote_options_loaded_generation()) {
+            g_form.gametype_index = gametype_cycler_index(options, is_match,
+                form_default_gametype(options, is_match, key), g_form.gametype_index);
+            pin_gametype_context(is_match);
+        }
+    }
+
+    // Clamped HERE, ahead of the level column that reads it: clamping after would filter
+    // the two passes of one frame on different game types.
+    const auto gametypes = selectable_gametypes(options, is_match);
+    const int gametype_count = static_cast<int>(gametypes.size());
+    g_form.gametype_index =
+        gametype_count > 0 ? std::clamp(g_form.gametype_index, 0, gametype_count - 1) : 0;
+
     const int col_gap = std::max(6, scaled(16.0f));
     const int left_w = (lo.cw - col_gap) / 2;
     const Rect left_col{lo.cx, y, left_w, body_bottom - y};
@@ -3022,7 +3182,7 @@ void do_form(PanelUi& ui, const Layout& lo, const VoteOptionsData& options,
 
     // Filtered live against the game type currently selected in the form; for
     // Match that cycler already offers only team types, so the two compose.
-    do_level_column(ui, lo, options, left_col, is_match, selected_gametype(options, is_match));
+    do_level_column(ui, lo, options, left_col, is_match, selected_gametype(gametypes));
 
     int ry = right_col.y;
     if (is_match) {
@@ -3048,39 +3208,85 @@ void do_form(PanelUi& ui, const Layout& lo, const VoteOptionsData& options,
     }
 
     {
-        const auto gametypes = selectable_gametypes(options, is_match);
-        const int count = static_cast<int>(gametypes.size()) + 1; // + "Default"
-        g_form.gametype_index = std::clamp(g_form.gametype_index, 0, count - 1);
-
         const int label_w = right_col.w / 2;
         if (ui.draw) {
             draw_label(ui, {right_col.x, ry + (lo.row_h - rf::gr::get_font_height(lo.font)) / 2, label_w,
                         lo.row_h}, "Game type", lo.font);
         }
-        const Rect cycler{right_col.x + label_w, ry, right_col.w - label_w, lo.row_h};
-        std::string text = "Default";
-        if (g_form.gametype_index > 0) {
-            const VoteGametypeInfo& gametype = *gametypes[g_form.gametype_index - 1];
+
+        const int avail = right_col.w - label_w;
+        const int reset_w = std::min(avail / 2,
+            rf::gr::get_string_size("Reset", lo.font).first + std::max(6, scaled(12.0f)));
+        const Rect cycler{right_col.x + label_w, ry,
+            gametype_cycler_width(gametypes, lo.font, avail - reset_w - lo.gap), lo.row_h};
+        std::string text = "-";
+        if (gametype_count > 0) {
+            const VoteGametypeInfo& gametype = *gametypes[g_form.gametype_index];
             const char* short_name = gametype_short_name(gametype.id);
-            text = short_name != nullptr
-                ? std::string{short_name}
-                // A game type this build predates has no short tag, so fall back
-                // to the server-sent display name, truncated to the selector.
-                : fit_middle(gametype.name, ui_cycler_value_width(cycler), lo.font);
+            // A game type this build predates has no short tag; the sent name stands in.
+            text = fit_middle(short_name != nullptr ? std::string_view{short_name}
+                                                    : std::string_view{gametype.name},
+                ui_cycler_value_width(cycler), lo.font);
         }
         const int delta = ui_cycler(ui, cycler, text.c_str(), lo.font);
-        if (delta != 0) {
-            g_form.gametype_index = (g_form.gametype_index + delta + count) % count;
+        if (delta != 0 && gametype_count > 0) {
+            g_form.gametype_index = (g_form.gametype_index + delta + gametype_count) % gametype_count;
+            g_form.gametype_touched = true; // the cycler is the player's from here on
+            play_click_sound();
+        }
+
+        // Back to the level's own game type, re-armed so it follows the level again.
+        const Rect reset{right_col.x + right_col.w - reset_w, ry, reset_w, lo.row_h};
+        if (ui_button(ui, reset, "Reset", lo.font, gametype_count > 0) && gametype_count > 0) {
+            g_form.gametype_index = gametype_cycler_index(gametypes,
+                form_default_gametype(options, is_match, selected_level()),
+                g_form.gametype_index);
+            g_form.gametype_touched = false;
+            pin_gametype_context(is_match);
             play_click_sound();
         }
+
         ry += lo.row_h + lo.gap * 2;
     }
 
-    if (ui.draw) {
-        set_header_color();
-        rf::gr::string(right_col.x, ry, "Mutators", lo.font);
+    {
+        const int header_h = rf::gr::get_font_height(lo.font);
+        if (ui.draw) {
+            set_header_color();
+            rf::gr::string(right_col.x, ry, "Mutators", lo.font);
+        }
+        // Current IS the auto baseline, so it re-arms; Base is a deviation, so it pins.
+        const int btn_pad = std::max(6, scaled(12.0f));
+        const int btn_cap = std::max(0, right_col.w / 4);
+        const int current_w =
+            std::min(btn_cap, rf::gr::get_string_size("Current", lo.font).first + btn_pad);
+        const int base_w =
+            std::min(btn_cap, rf::gr::get_string_size("Base", lo.font).first + btn_pad);
+
+        const std::string current_label = fit_middle("Current", current_w, lo.font);
+        const std::string base_label = fit_middle("Base", base_w, lo.font);
+
+        const auto apply_and_pin = [&](const std::vector<VoteMutatorDecl>& baseline, bool touched) {
+            apply_baseline(options, baseline);
+            g_form.mutators_touched = touched;
+            pin_mutator_baseline_context();
+            g_form.mutator_scroll = 0.0f;
+            play_click_sound();
+        };
+
+        const Rect current{right_col.x + right_col.w - current_w, ry - 1, current_w, header_h + 2};
+        if (ui_button(ui, current, current_label.c_str(), lo.font)) {
+            apply_and_pin(resolve_baseline(options, selected_level()), false);
+        }
+
+        // Disabled, not applied as an empty set: "base runs nothing" is not "base unknown".
+        const Rect base{current.x - lo.gap - base_w, ry - 1, base_w, header_h + 2};
+        if (ui_button(ui, base, base_label.c_str(), lo.font, options.base_mutator_decls_present)
+            && options.base_mutator_decls_present) {
+            apply_and_pin(options.base_mutator_decls, true);
+        }
+        ry += header_h + lo.gap;
     }
-    ry += rf::gr::get_font_height(lo.font) + lo.gap;
 
     // Reserve exactly three lines at the bottom of the column for the description;
     // everything between the header and it scrolls.
@@ -3090,7 +3296,7 @@ void do_form(PanelUi& ui, const Layout& lo, const VoteOptionsData& options,
     const Rect mutator_view{right_col.x, ry, right_col.w, std::max(lo.row_h, mutator_bottom - ry)};
     // Resolved after the game type cycler above has consumed this frame's input,
     // so moving it greys the affected mutators on the same frame.
-    const uint8_t mutator_gametype = effective_gametype(options, is_match);
+    const uint8_t mutator_gametype = effective_gametype(options, gametypes);
     // Same reason this is here and not in the cycler block: the score limit default
     // has to settle against the type chosen THIS frame, before the option row that
     // shows it is drawn below.
@@ -3145,8 +3351,15 @@ void vote_panel_do(PanelUi& ui)
     if (mode == PanelMode::Form && options) {
         ensure_form(*options);
         tabs = enabled_vote_tabs();
-        if (!tabs.empty()) {
-            g_form.type_index = std::clamp(g_form.type_index, 0, static_cast<int>(tabs.size()) - 1);
+        // A blob refresh disabling a vote type shrinks the list under the form, which is
+        // as much a tab change as a button press. Hit-test pass only.
+        if (!ui.draw && !tabs.empty()) {
+            const int clamped =
+                std::clamp(g_form.type_index, 0, static_cast<int>(tabs.size()) - 1);
+            if (clamped != g_form.type_index) {
+                g_form.type_index = clamped;
+                reset_gametype_selection();
+            }
         }
     }
 
@@ -3207,13 +3420,9 @@ void vote_panel_do(PanelUi& ui)
 
     bool can_send = false;
     bool can_save = false;
-    if (g_form.on_saved_tab) {
-        can_send = !vote_active && options != nullptr && g_saved_selected >= 0
-            && g_saved_selected < static_cast<int>(saved_votes_get().size())
-            && g_saved_selected < static_cast<int>(g_saved_availability.size())
-            && g_saved_availability[g_saved_selected].callable;
-    }
-    else if (options != nullptr) {
+    // A saved entry is called by loading it into the form with EDIT, so the saved
+    // tab leaves CALL VOTE greyed rather than sending whatever the form holds.
+    if (!g_form.on_saved_tab && options != nullptr) {
         can_send = !vote_active && vote_form_is_sendable(*options);
         // Saving is local, so it is deliberately NOT gated on vote_active; only
         // the three savable types offer it.
@@ -3221,17 +3430,12 @@ void vote_panel_do(PanelUi& ui)
         const VoteTab* tab_now = selected_tab(tabs_now);
         const VoteTypeInfo* selected_now = tab_now ? tab_selected_type(*tab_now) : nullptr;
         can_save = selected_now != nullptr && saved_vote_type_is_savable(selected_now->type)
-            && vote_form_is_sendable(*options);
+            && vote_form_is_sendable(*options, true) && !saved_votes_is_full();
     }
 
     const Rect call{row_x, btn_y, btn_w, btn_h};
     if (ui_button(ui, call, "CALL VOTE", lo.font, can_send) && can_send) {
-        if (g_form.on_saved_tab) {
-            send_saved_vote(saved_votes_get()[static_cast<size_t>(g_saved_selected)], *options);
-        }
-        else {
-            send_vote_from_form(*options);
-        }
+        send_vote_from_form(*options);
         return;
     }
 
@@ -3252,6 +3456,64 @@ void vote_panel_do(PanelUi& ui)
 // Gameplay overlay driving
 // ---------------------------------------------------------------------------
 
+// A stock popup runs the gameplay state with no_input=1, so the controls loop -- the
+// only consumer of the per-scan-code down counters -- never runs, and they would fire
+// their bindings when it closes. Driven through the engine's own consumer.
+void drain_bound_key_counters()
+{
+    rf::Player* const player = rf::local_player;
+    if (!player) {
+        return;
+    }
+    rf::ControlConfig& cc = player->settings.controls;
+    const int count = std::min(cc.num_bindings, 128);
+    for (int action = 0; action < count; ++action) {
+        // Unfiltered: a vetoed read is exactly the one that must reach the engine.
+        control_input_filter_check_pressed_unfiltered(
+            &cc, static_cast<rf::ControlConfigAction>(action), nullptr);
+    }
+}
+
+// Fold the recorded keys into the focused box, in arrival order. Must run at the TOP
+// of the hit-test pass so both passes of the frame read the same string.
+void apply_pending_text_input()
+{
+    if (g_text_input_pending.empty()) {
+        return;
+    }
+    std::vector<PendingTextKey> queue;
+    queue.swap(g_text_input_pending);
+
+    for (const PendingTextKey& pending : queue) {
+        if (g_text_input_focus == 0) {
+            break; // an ESC or ENTER earlier in the burst ended the edit
+        }
+        std::string* const text = g_text_input_target.text;
+        switch (pending.kind) {
+            case PendingTextKey::Kind::Escape:
+                text_input_release_focus(false);
+                play_click_sound();
+                break;
+            case PendingTextKey::Kind::Enter:
+                text_input_release_focus(true);
+                break;
+            case PendingTextKey::Kind::Backspace:
+                if (text && !text->empty()) {
+                    text->pop_back();
+                    g_text_input_changed = true;
+                }
+                break;
+            case PendingTextKey::Kind::Char:
+                if (text && g_text_input_target.allow_char(pending.c)
+                    && text->size() < g_text_input_target.max_len) {
+                    text->push_back(pending.c);
+                    g_text_input_changed = true;
+                }
+                break;
+        }
+    }
+}
+
 void vote_panel_gameplay_input()
 {
     if (!g_open) {
@@ -3268,10 +3530,11 @@ void vote_panel_gameplay_input()
     // Re-assert every frame; respawns and camera changes reset mouse mode.
     gameplay_overlay_apply_mouse(true);
 
-    // A stock popup (extend duration, saved-vote name) takes over input while
-    // it is up. gameseq_process passes no_input=1 to the state's own frame, but
+    // A stock popup (the saved-vote name prompt) takes over input while it is
+    // up. gameseq_process passes no_input=1 to the state's own frame, but
     // this gameplay pump runs outside that, so it has to check explicitly.
     if (rf::ui::popup_is_active()) {
+        drain_bound_key_counters();
         return; // the popup owns input; panel keeps rendering underneath
     }
 
@@ -3281,6 +3544,8 @@ void vote_panel_gameplay_input()
         text_input_release_focus(true);
     }
 
+    apply_pending_text_input();
+
     // Read the wheel accumulator before touching the mouse API.
     const int wheel = rf::mouse_dz;
 
@@ -3350,9 +3615,47 @@ CallHook<rf::GameState()> gameseq_process_hook{
     },
 };
 
-// ESC during gameplay pushes GS_MAIN_MENU. While the overlay is up, treat that
-// as "close the modal" and swallow the push, so ESC dismisses the panel and the
-// ESC menu can never open on top of the overlay.
+// A focused panel box takes precedence, everything else passes straight through. Keys
+// are only RECORDED here (see PendingTextKey), but still swallowed, so nothing fires.
+FunHook<void(int)> gameplay_key_callback_hook{
+    0x004306F0,
+    [](int key) {
+        if (key == rf::KEY_NONE || !g_open || g_text_input_focus == 0) {
+            gameplay_key_callback_hook.call_target(key);
+            return;
+        }
+
+        const auto queue = [](PendingTextKey pending) {
+            if (g_text_input_pending.size() < TEXT_INPUT_PENDING_MAX) {
+                g_text_input_pending.push_back(pending);
+            }
+        };
+
+        const int code = key & rf::KEY_MASK;
+        if (code == rf::KEY_ESC) {
+            queue({PendingTextKey::Kind::Escape, 0});
+            return;
+        }
+        if (code == rf::KEY_ENTER || code == rf::KEY_PADENTER) {
+            queue({PendingTextKey::Kind::Enter, 0});
+            return;
+        }
+        if (!g_text_input_target.text) {
+            return;
+        }
+        if (code == rf::KEY_BACKSP) {
+            queue({PendingTextKey::Kind::Backspace, 0});
+            return;
+        }
+        const int ascii = rf::key_to_ascii(static_cast<int16_t>(key));
+        if (ascii > 0 && ascii < 0x80 && ascii != 0xFF) {
+            queue({PendingTextKey::Kind::Char, static_cast<char>(ascii)});
+        }
+    },
+};
+
+// ESC during gameplay pushes GS_MAIN_MENU; while the overlay is up that is swallowed
+// and read as "close the modal". A focused text box never reaches here.
 FunHook<void(rf::GameState, bool, bool)> gameseq_push_state_hook{
     0x00434410,
     [](rf::GameState state, bool transparent, bool pause_beneath) {
@@ -3362,15 +3665,6 @@ FunHook<void(rf::GameState, bool, bool)> gameseq_push_state_hook{
             return;
         }
         if (state == rf::GS_MAIN_MENU && g_open) {
-            // ESC backs out one layer at a time: first out of a focused text box,
-            // then out of the panel. Normally the focused box consumes ESC from
-            // the key queue itself; this is the fallback for a race where the
-            // game's own handler saw the key first.
-            if (g_text_input_focus != 0) {
-                text_input_release_focus(false);
-                play_click_sound();
-                return;
-            }
             vote_panel_close();
             play_click_sound();
             return;
@@ -3507,6 +3801,11 @@ bool vote_panel_is_gameplay_overlay_active()
     return g_open;
 }
 
+bool vote_panel_is_capturing_text()
+{
+    return g_open && g_text_input_focus != 0;
+}
+
 void vote_panel_reset()
 {
     // Every field of the form describes the server being left.
@@ -3569,4 +3868,5 @@ void vote_panel_apply_patch()
     gameseq_process_hook.install();
     gameseq_push_state_hook.install();
     gameseq_state_do_frame_hook.install();
+    gameplay_key_callback_hook.install();
 }
diff --git a/game_patch/misc/vote_panel.h b/game_patch/misc/vote_panel.h
index 506306a7b..304470234 100644
--- a/game_patch/misc/vote_panel.h
+++ b/game_patch/misc/vote_panel.h
@@ -8,6 +8,11 @@ void vote_panel_close();
 void vote_panel_toggle_gameplay();
 // True while the overlay is up; drives HUD/chat/input suppression.
 bool vote_panel_is_gameplay_overlay_active();
+// True while a panel text box has focus, i.e. keystrokes are being typed into the
+// panel. Anything that reads key state directly (rather than through the control
+// config, which the panel's veto already covers) has to consult this the same way
+// it consults console/chat visibility.
+bool vote_panel_is_capturing_text();
 // Drop the whole form (leaving a server).
 void vote_panel_reset();
 
diff --git a/game_patch/misc/vpackfile.cpp b/game_patch/misc/vpackfile.cpp
index d6ce32683..8340c9be0 100644
--- a/game_patch/misc/vpackfile.cpp
+++ b/game_patch/misc/vpackfile.cpp
@@ -479,6 +479,10 @@ bool vpackfile_supercede_allowed(const char* requested_filename, const char* sib
 static void vpackfile_add_to_lookup_table(rf::VPackfileEntry* entry)
 {
     std::string filename_str = string_to_lower(entry->name);
+    // dedicated servers don't need .awp files.
+    if (rf::is_dedicated_server && filename_str.ends_with(".awp")) {
+        return;
+    }
     auto [it, inserted] = g_loopup_table.insert({filename_str, entry});
     if (!inserted) {
         ++g_num_name_collisions;
@@ -672,8 +676,9 @@ static void vpackfile_init_new()
     if (!rf::is_dedicated_server) {
         rf::vpackfile_add("music.vpp", nullptr);
         rf::vpackfile_add("ui.vpp", nullptr);
-        load_alpinefaction_vpp();
     }
+
+    load_alpinefaction_vpp();
     rf::vpackfile_add("tables.vpp", nullptr);
     addr_as_ref<int>(0x01BDB218) = 1;          // VPackfilesLoaded
     addr_as_ref<uint32_t>(0x01BDB210) = 10000; // NumFilesInVfs
diff --git a/game_patch/misc/waypoints_utils.cpp b/game_patch/misc/waypoints_utils.cpp
index 55db36634..af61c5961 100644
--- a/game_patch/misc/waypoints_utils.cpp
+++ b/game_patch/misc/waypoints_utils.cpp
@@ -1,6 +1,7 @@
 #include "waypoints_utils.h"
 #include "waypoints_internal.h"
 #include "alpine_settings.h"
+#include "vote_panel.h"
 #include "../hud/multi_spectate.h"
 #include "../rf/collide.h"
 #include "../rf/entity.h"
@@ -944,6 +945,14 @@ void handle_waypoint_editor_input()
         return;
     }
 
+    // Raw key read, so the control veto does not cover it: a focused vote panel box
+    // owns the keyboard. Consumed and discarded rather than left standing, which
+    // would delete the selection on the frame after the box loses focus.
+    if (vote_panel_is_capturing_text()) {
+        rf::key_get_and_reset_down_counter(rf::KEY_DELETE);
+        return;
+    }
+
     if (rf::key_get_and_reset_down_counter(rf::KEY_DELETE) > 0) {
         delete_selected_waypoint_editor_object();
     }
@@ -1907,11 +1916,43 @@ void append_text_from_count(std::string& field, const int count, const char ch)
     }
 }
 
+// These pumps are raw key reads, so the control veto does not cover them.
+bool drain_dialog_keys_while_panel_captures(const bool with_minus = false)
+{
+    if (!vote_panel_is_capturing_text()) {
+        return false;
+    }
+
+    rf::key_get_and_reset_down_counter(rf::KEY_ESC);
+    rf::key_get_and_reset_down_counter(rf::KEY_ENTER);
+    rf::key_get_and_reset_down_counter(rf::KEY_PADENTER);
+    rf::key_get_and_reset_down_counter(rf::KEY_BACKSP);
+    if (with_minus) {
+        rf::key_get_and_reset_down_counter(rf::KEY_MINUS);
+        rf::key_get_and_reset_down_counter(rf::KEY_PADMINUS);
+    }
+    // Both halves of every digit: the raw counter and anything key.cpp stashed
+    // before the box took focus.
+    for (int key = rf::KEY_1; key <= rf::KEY_0; ++key) {
+        rf::key_get_and_reset_down_counter(static_cast<rf::Key>(key));
+        waypoints_utils_consume_numeric_key(key);
+    }
+    // Keypad digits are not contiguous in the scancode order.
+    for (const rf::Key key : {rf::KEY_PAD0, rf::KEY_PAD1, rf::KEY_PAD2, rf::KEY_PAD3, rf::KEY_PAD4,
+                              rf::KEY_PAD5, rf::KEY_PAD6, rf::KEY_PAD7, rf::KEY_PAD8, rf::KEY_PAD9}) {
+        rf::key_get_and_reset_down_counter(key);
+    }
+    return true;
+}
+
 void process_link_editor_keyboard_input()
 {
     if (!g_waypoint_link_editor_dialog.open || !g_waypoint_editor_mouse_ui_mode) {
         return;
     }
+    if (drain_dialog_keys_while_panel_captures(true)) {
+        return;
+    }
 
     if (rf::key_get_and_reset_down_counter(rf::KEY_ESC) > 0) {
         close_waypoint_link_editor_dialog(false);
@@ -2012,6 +2053,9 @@ void process_zone_create_trigger_uid_keyboard_input()
         || !g_waypoint_editor_mouse_ui_mode) {
         return;
     }
+    if (drain_dialog_keys_while_panel_captures()) {
+        return;
+    }
 
     if (rf::key_get_and_reset_down_counter(rf::KEY_ESC) > 0) {
         close_waypoint_zone_create_dialog();
@@ -2150,6 +2194,9 @@ void process_bridge_waypoint_keyboard_input()
         || !g_waypoint_editor_mouse_ui_mode) {
         return;
     }
+    if (drain_dialog_keys_while_panel_captures()) {
+        return;
+    }
 
     if (rf::key_get_and_reset_down_counter(rf::KEY_ESC) > 0) {
         close_waypoint_zone_create_dialog();
@@ -2222,6 +2269,9 @@ void process_target_link_editor_keyboard_input()
     if (!g_waypoint_target_link_editor_dialog.open || !g_waypoint_editor_mouse_ui_mode) {
         return;
     }
+    if (drain_dialog_keys_while_panel_captures()) {
+        return;
+    }
 
     if (rf::key_get_and_reset_down_counter(rf::KEY_ESC) > 0) {
         close_target_link_editor_dialog(false);
@@ -2298,6 +2348,9 @@ void process_zone_bridge_editor_keyboard_input()
     if (!g_waypoint_zone_bridge_editor_dialog.open || !g_waypoint_editor_mouse_ui_mode) {
         return;
     }
+    if (drain_dialog_keys_while_panel_captures()) {
+        return;
+    }
 
     if (rf::key_get_and_reset_down_counter(rf::KEY_ESC) > 0) {
         close_zone_bridge_editor_dialog(false);
diff --git a/game_patch/multi/alpine_packets.cpp b/game_patch/multi/alpine_packets.cpp
index 05a595f12..07834bd27 100644
--- a/game_patch/multi/alpine_packets.cpp
+++ b/game_patch/multi/alpine_packets.cpp
@@ -1095,7 +1095,9 @@ struct VoteWriter
             ok = false;
             return;
         }
-        std::memcpy(buf + off, src, n);
+        if (n) {
+            std::memcpy(buf + off, src, n); // an empty vector's data() may be null
+        }
         off += n;
     }
 };
@@ -1326,12 +1328,15 @@ void af_send_vote_call(const AfVoteCallParams& params)
             w.str(params.level);
             w.u8(params.gametype);
             encoded = write_vote_mutators(w, params.mutators);
+            // Trailing and optional; see af_vote_call_flags.
+            w.u8(params.mutators_explicit ? AF_VOTE_CALL_FLAG_MUTATORS_EXPLICIT : uint8_t{0});
             break;
         case AfVoteType::Match:
             w.u8(params.team_size);
             w.str(params.level);
             w.u8(params.gametype);
             encoded = write_vote_mutators(w, params.mutators);
+            w.u8(params.mutators_explicit ? AF_VOTE_CALL_FLAG_MUTATORS_EXPLICIT : uint8_t{0});
             break;
         case AfVoteType::Extend:
             w.u8(params.extend_minutes);
@@ -1521,6 +1526,72 @@ void af_send_vote_state_end(rf::Player* player, AfVoteResult result, bool passed
     af_finish_vote_state_packet(player, buf, w);
 }
 
+// The mutator set the session is running, which is what the vote panel pre-selects.
+// NOT part of the vote-options blob: that is config-derived and cached behind a
+// generation, while this changes with every vote that installs an override.
+// Whether the declarations plus the req-type byte fit one packet. A property of the
+// blob, not of the recipient, so a fan-out answers it once.
+static bool af_active_mutators_blob_fits(const std::vector<uint8_t>& decls)
+{
+    if (sizeof(RF_GamePacketHeader) + 1 + decls.size() <= rf::max_packet_size) {
+        return true;
+    }
+    xlog::warn("af_send_active_mutators: {} bytes of declarations do not fit a packet", decls.size());
+    return false;
+}
+
+static void af_send_active_mutators_blob(rf::Player* player, const std::vector<uint8_t>& decls)
+{
+    if (!af_vote_recipient_is_structured(player)) {
+        return;
+    }
+
+    std::byte buf[rf::max_packet_size];
+    VoteWriter w{buf, sizeof(buf), sizeof(RF_GamePacketHeader)};
+    w.u8(static_cast<uint8_t>(af_server_req_type::af_sreq_active_mutators));
+    w.bytes(decls.data(), decls.size());
+    if (!w.ok) {
+        return; // size already reported by af_active_mutators_blob_fits
+    }
+
+    RF_GamePacketHeader header{};
+    header.type = static_cast<uint8_t>(af_packet_type::af_server_req);
+    header.size = static_cast<uint16_t>(w.off - sizeof(header));
+    std::memcpy(buf, &header, sizeof(header));
+    af_send_packet(player, buf, static_cast<int>(w.off), true);
+}
+
+void af_send_active_mutators(rf::Player* player)
+{
+    if (!rf::is_server) {
+        return;
+    }
+    std::vector<uint8_t> decls;
+    server_vote_build_active_mutators_blob(decls);
+    if (!af_active_mutators_blob_fits(decls)) {
+        return;
+    }
+    af_send_active_mutators_blob(player, decls);
+}
+
+void af_send_active_mutators_to_all()
+{
+    if (!rf::is_server) {
+        return;
+    }
+    // Built once: building it walks the mutator registry.
+    std::vector<uint8_t> decls;
+    server_vote_build_active_mutators_blob(decls);
+    if (!af_active_mutators_blob_fits(decls)) {
+        return;
+    }
+
+    auto player_list = SinglyLinkedList{rf::player_list};
+    for (auto& player : player_list) {
+        af_send_active_mutators_blob(&player, decls);
+    }
+}
+
 // Stream the vote-options blob as Begin -> Data* -> End on the deferred reliable
 // queue. Everything on that queue is drained FIFO into rf::net_rel_send, which is
 // an ordered reliable channel, so the client sees the three event kinds in the
@@ -1868,6 +1939,14 @@ static void af_process_client_req_packet(const void* data, size_t len, const rf:
                     break; // parameterless vote types
             }
 
+            // Optional trailing flags byte, read here because it sits directly behind
+            // the mutator section. Omitted means explicit only if a mutator was named.
+            if (params.type == AfVoteType::Level || params.type == AfVoteType::Match) {
+                params.mutators_explicit = r.remaining() > 0
+                    ? (r.u8() & AF_VOTE_CALL_FLAG_MUTATORS_EXPLICIT) != 0
+                    : !params.mutators.empty();
+            }
+
             if (!r.ok) {
                 xlog::warn("af_process_client_req_packet: truncated vote call payload");
                 return;
@@ -2888,6 +2967,10 @@ static void af_process_server_req_packet(const void* data, size_t len, const rf:
             }
             break;
         }
+        case af_server_req_type::af_sreq_active_mutators: {
+            vote_active_mutators_on_received(bytes + offset, remaining);
+            break;
+        }
         case af_server_req_type::af_sreq_vote_options_data: {
             VoteReader r{bytes + offset, remaining};
             const uint8_t event = r.u8();
diff --git a/game_patch/multi/alpine_packets.h b/game_patch/multi/alpine_packets.h
index e22c671b3..523d4ded4 100644
--- a/game_patch/multi/alpine_packets.h
+++ b/game_patch/multi/alpine_packets.h
@@ -182,7 +182,10 @@ enum af_vote_end_flags : uint8_t
 // Repeated records in the blob are length-prefixed, so additions to the blob
 // are not compatibility breaking. This version should be incremented only if
 // the core format changes - like redefining a field or reordering/removing them.
-constexpr uint8_t af_vote_options_blob_version = 1;
+//
+// 2: the trailing base mutator section gained a u16 length prefix of its own,
+//    which redefines bytes version 1 wrote as a bare declaration set.
+constexpr uint8_t af_vote_options_blob_version = 2;
 
 // af_sreq_vote_options_data stream framing. The blob is pushed as
 // Begin -> Data* -> End over the ordered reliable channel, so no chunk index or
@@ -219,6 +222,15 @@ enum af_vote_level_flags : uint8_t
     AF_VOTE_LEVEL_FLAG_ALLOWED = 1 << 0,
 };
 
+// The optional trailing flags byte of a Level/Match vote call. Reserved bits are
+// ignored; an ABSENT byte means "explicit iff the vote named any mutator".
+enum af_vote_call_flags : uint8_t
+{
+    // `mutators` is the complete selection, empty included. Clear means "keep
+    // whatever set the session is running".
+    AF_VOTE_CALL_FLAG_MUTATORS_EXPLICIT = 1 << 0,
+};
+
 // The `baseline_kind` byte appended after a level entry's flags: which mutator
 // set the vote panel pre-selects when that level is picked.
 enum class AfVoteLevelBaseline : uint8_t
@@ -322,6 +334,7 @@ enum class af_server_req_type : uint8_t
     af_sreq_jetpack_state = 0x9,       // Alpine 1.4 (5 bytes: obj_handle, on)
     af_sreq_riot_shield_state = 0xA,   // Alpine 1.4 (20 bytes: obj_handle, life, impact_pos)
     af_sreq_award = 0xB,               // Alpine 1.4 (2 bytes: award_id, victim_player_id; 0xFF = no victim)
+    af_sreq_active_mutators = 0xC,     // Alpine 1.4 (variable: one declaration set, see blob_declaration_set)
 };
 
 struct ShouldGibPayload
@@ -801,6 +814,8 @@ struct AfVoteCallParams
     uint8_t gametype = af_vote_gametype_none;
     uint8_t extend_minutes = af_vote_extend_default_minutes;
     std::vector<VoteMutatorInput> mutators;
+    // False means "inherit the session's set", the legacy/chat-vote meaning.
+    bool mutators_explicit = false;
     bool preserve = true;
 };
 
@@ -911,6 +926,10 @@ void af_send_vote_state_update(rf::Player* player, uint8_t yes, uint8_t no, uint
 void af_send_vote_state_end(rf::Player* player, AfVoteResult result, bool passed,
                             std::string_view detail);
 void af_send_vote_options_data(rf::Player* player);
+// Push the mutator set currently in force. Called on join and whenever the active
+// rules are (re)applied.
+void af_send_active_mutators(rf::Player* player);
+void af_send_active_mutators_to_all();
 
 // server -> client state (Pit + match ready system)
 void af_send_ready_prompt(rf::Player* player, uint8_t state); // 0/1/2 (see ReadyPromptPayload)
diff --git a/game_patch/multi/dedi_cfg.cpp b/game_patch/multi/dedi_cfg.cpp
index 86517b065..46556d8a0 100644
--- a/game_patch/multi/dedi_cfg.cpp
+++ b/game_patch/multi/dedi_cfg.cpp
@@ -396,6 +396,10 @@ void apply_defaults_for_game_type(rf::NetGameType game_type, AlpineServerConfigR
             rules.spawn_delay.enabled = true;
             rules.spawn_delay.set_base_value(2.0f);
             rules.location_pinging = (game_type == rf::NetGameType::NG_TYPE_TBAG);
+
+            // primary weapon
+            rules.default_player_weapon.set_weapon("12mm handgun");
+
             break;
         }
 
@@ -508,52 +512,26 @@ void apply_defaults_for_game_type(rf::NetGameType game_type, AlpineServerConfigR
     }
 }
 
-// Set while a scope is re-parsed to DERIVE a second rules variant (the
-// mutator-free baseline vote overrides start from). That pass walks the same TOML
-// and re-reads the same preset files, so without this every preset warning and
-// error was printed twice per scope — the repeat tagged "(no mutators)", which an
-// admin has no way to interpret. The first pass is the one that reports problems.
-static bool g_rules_parse_quiet = false;
+bool g_rules_parse_quiet = false;
 
-struct RulesParseQuietGuard
+// What a parse pass over a rules scope is allowed to touch.
+enum class RulesParseMode
 {
-    bool previous;
-    RulesParseQuietGuard() : previous(g_rules_parse_quiet) { g_rules_parse_quiet = true; }
-    ~RulesParseQuietGuard() { g_rules_parse_quiet = previous; }
-    RulesParseQuietGuard(const RulesParseQuietGuard&) = delete;
-    RulesParseQuietGuard& operator=(const RulesParseQuietGuard&) = delete;
+    Full,       // game type resolution, gametype defaults, mutators, explicit keys
+    NoMutators, // the same, minus the mutator declarations
+    KeysOnly,   // only the explicit keys
 };
 
-// parse toml rules
-// for base rules, load all speciifed. For not specified, defaults are in struct
-// for level-specific rules, start with base rules and load anything specified beyond that
-AlpineServerConfigRules parse_server_rules(const toml::table& t, const AlpineServerConfigRules& base_rules, bool apply_mutators = true)
+struct RulesParseOptions
 {
-    AlpineServerConfigRules o = base_rules;
-
-    rf::NetGameType resolved_game_type = o.game_type;
-    if (auto v = t["game_type"].value<std::string>()) {
-        auto gt_opt = resolve_gametype_from_name(*v);
-        resolved_game_type = gt_opt.has_value() ? gt_opt.value() : rf::NetGameType::NG_TYPE_DM;
-    }
-
-    const bool game_type_changed = resolved_game_type != base_rules.game_type;
-
-    o.game_type = resolved_game_type;
-
-    if (game_type_changed || !o.game_type_defaults_applied)
-        apply_defaults_for_game_type(o.game_type, o);
-
-    // Mutators are applied after the gametype defaults but before any explicitly
-    // set rule keys in this scope, so manual keys still override mutator presets.
-    // parse_server_rules runs once per scope (base, then each level), which yields
-    // the requested layering: gametype defaults -> base mutators -> manual base ->
-    // per-level mutators -> manual per-level.
-    if (apply_mutators) {
-        if (auto mut_arr = t["mutators"].as_array())
-            apply_mutators_from_toml(*mut_arr, o);
-    }
+    RulesParseMode mode = RulesParseMode::Full;
+    // Struct defaults plus the operator's explicit base keys. A scope resolving a
+    // DIFFERENT game type is rebuilt from this rather than inheriting what it was handed.
+    const AlpineServerConfigRules* rebase_source = nullptr;
+};
 
+static void apply_rules_keys_from_toml(const toml::table& t, AlpineServerConfigRules& o)
+{
     if (auto v = t["time_limit"].value<float>())
         o.set_time_limit(*v);
     if (auto v = t["overtime"].as_table())
@@ -777,7 +755,22 @@ AlpineServerConfigRules parse_server_rules(const toml::table& t, const AlpineSer
     }
     if (auto v = t["gg_final_weapon"].value<std::string>())
         o.gungame_final_weapon = *v;
+}
+
+// Applies one rules table: mutators (Full mode only) then explicit keys, so manual
+// keys always win. Across scopes: gametype defaults -> base mutators -> manual base
+// -> per-level mutators -> manual per-level.
+static AlpineServerConfigRules parse_server_rules(const toml::table& t, const AlpineServerConfigRules& base_rules,
+                                                  const RulesParseOptions& opts = {})
+{
+    AlpineServerConfigRules o = base_rules;
+
+    if (opts.mode == RulesParseMode::Full) {
+        if (auto mut_arr = t["mutators"].as_array())
+            apply_mutators_from_toml(*mut_arr, o);
+    }
 
+    apply_rules_keys_from_toml(t, o);
     return o;
 }
 
@@ -968,156 +961,55 @@ static AlpineRestrictConfig parse_alpine_restrict_config(const toml::table &t)
 
 namespace fs = std::filesystem;
 
-static AlpineServerConfigRules apply_rules_presets_and_overrides(
-    const toml::table& scope_tbl, const fs::path& base_dir, const AlpineServerConfigRules& starting_rules,
-    std::string_view context, const std::map<std::string, std::filesystem::path>* preset_aliases = nullptr,
-    std::vector<fs::path>* preset_stack = nullptr, std::vector<std::pair<std::filesystem::path, std::optional<std::string>>>* applied_presets = nullptr,
-    bool apply_mutators = true)
+// A scope can carry rule keys at its top level AND in a nested [.rules] table; both
+// are applied, top level first.
+static AlpineServerConfigRules parse_scope_rules(
+    const toml::table& scope_tbl, const AlpineServerConfigRules& starting_rules,
+    const RulesParseOptions& opts = {})
 {
-    std::vector<fs::path> local_stack;
-    const bool is_root_call = !preset_stack;
-    if (!preset_stack)
-        preset_stack = &local_stack;
-
-    if (is_root_call && applied_presets)
-        applied_presets->clear();
-
     AlpineServerConfigRules rules = starting_rules;
+    const toml::table* nested_rules_tbl = scope_tbl["rules"].as_table();
 
-    auto apply_preset = [&](std::string_view preset_path) {
-        bool used_alias = false;
-        fs::path resolved_path;
+    if (opts.mode != RulesParseMode::KeysOnly) {
+        // Either table may declare the game type, nested wins. Resolved before any key
+        // is applied, so the second table cannot discard the first.
+        std::optional<std::string> game_type_name;
+        if (nested_rules_tbl)
+            game_type_name = (*nested_rules_tbl)["game_type"].value<std::string>();
+        if (!game_type_name)
+            game_type_name = scope_tbl["game_type"].value<std::string>();
 
-        if (preset_aliases) {
-            auto alias_it = preset_aliases->find(std::string(preset_path));
-            if (alias_it != preset_aliases->end()) {
-                resolved_path = alias_it->second;
-                used_alias = true;
-            }
-        }
+        rf::NetGameType resolved_game_type = rules.game_type;
+        if (game_type_name)
+            resolved_game_type = resolve_gametype_from_name(*game_type_name).value_or(rf::NetGameType::NG_TYPE_DM);
 
-        if (resolved_path.empty())
-            resolved_path = base_dir / preset_path;
+        const bool game_type_changed = resolved_game_type != starting_rules.game_type;
 
-        try {
-            resolved_path = fs::weakly_canonical(resolved_path);
-        }
-        catch (const fs::filesystem_error& err) {
-            if (!g_rules_parse_quiet)
-                rf::console::print("  [WARN] failed to canonicalize rules preset '{}' in {}: {}\n", resolved_path.generic_string(), context, err.what());
-            resolved_path = fs::absolute(resolved_path);
-        }
-
-        if (std::find(preset_stack->begin(), preset_stack->end(), resolved_path) != preset_stack->end()) {
-            if (!g_rules_parse_quiet)
-                rf::console::print("  [ERROR] rules preset cycle detected at '{}' in {}\n", resolved_path.generic_string(), context);
-            return;
-        }
-
-        preset_stack->push_back(resolved_path);
-        try {
-            toml::table preset_root = toml::parse_file(resolved_path.generic_string());
-            const toml::table* preset_rules = nullptr;
-
-            if (auto tbl = preset_root["rules"].as_table())
-                preset_rules = tbl;
-            else
-                preset_rules = &preset_root;
+        if (game_type_changed && opts.rebase_source)
+            rules = *opts.rebase_source;
 
-            std::string next_context = std::format("rules preset '{}'", resolved_path.generic_string());
-            rules = apply_rules_presets_and_overrides(*preset_rules, resolved_path.parent_path(), rules, next_context, preset_aliases, preset_stack, applied_presets, apply_mutators);
-            if (applied_presets) {
-                if (used_alias)
-                    applied_presets->emplace_back(resolved_path, preset_path);
-                else
-                    applied_presets->emplace_back(resolved_path, std::nullopt);
-            }
-        }
-        catch (const toml::parse_error& err) {
-            if (!g_rules_parse_quiet)
-                rf::console::print("  [ERROR] failed to parse rules preset '{}' in {}: {}\n", resolved_path.generic_string(), context, err.description());
-        }
-        preset_stack->pop_back();
-    };
+        rules.game_type = resolved_game_type;
 
-    if (auto presets = scope_tbl["rules_presets"]) {
-        if (auto arr = presets.as_array()) {
-            for (auto& node : *arr) {
-                if (auto preset = node.value<std::string>())
-                    apply_preset(*preset);
-                else if (!g_rules_parse_quiet)
-                    rf::console::print("  [WARN] rules_presets entries in {} must be strings.\n", context);
-            }
-        }
-        else if (auto preset = presets.value<std::string>()) {
-            apply_preset(*preset);
-        }
-        else if (!g_rules_parse_quiet) {
-            rf::console::print("  [WARN] 'rules_presets' in {} must be a string or array of strings.\n", context);
-        }
+        if (game_type_changed || !rules.game_type_defaults_applied)
+            apply_defaults_for_game_type(rules.game_type, rules);
     }
 
-    // Allow presets to specify rule keys directly at the current scope.
-    rules = parse_server_rules(scope_tbl, rules, apply_mutators);
+    rules = parse_server_rules(scope_tbl, rules, opts);
 
-    if (auto rules_tbl = scope_tbl["rules"].as_table())
-        rules = parse_server_rules(*rules_tbl, rules, apply_mutators);
+    if (nested_rules_tbl)
+        rules = parse_server_rules(*nested_rules_tbl, rules, opts);
 
     return rules;
 }
 
-std::optional<ManualRulesOverride> load_rules_preset_alias(std::string_view preset_name)
-{
-    const auto it = g_alpine_server_config.rules_preset_aliases.find(std::string(preset_name));
-    if (it == g_alpine_server_config.rules_preset_aliases.end())
-        return std::nullopt;
-
-    fs::path resolved_path = it->second;
-    try {
-        resolved_path = fs::weakly_canonical(resolved_path);
-    }
-    catch (const fs::filesystem_error& err) {
-        rf::console::print("  [WARN] failed to canonicalize rules preset alias '{}' at '{}': {}\n", preset_name, resolved_path.generic_string(), err.what());
-        resolved_path = fs::absolute(resolved_path);
-    }
-
-    std::vector<std::pair<std::filesystem::path, std::optional<std::string>>> applied_presets;
-
-    try {
-        toml::table preset_root = toml::parse_file(resolved_path.generic_string());
-        const toml::table* preset_rules = nullptr;
-
-        if (auto tbl = preset_root["rules"].as_table())
-            preset_rules = tbl;
-        else
-            preset_rules = &preset_root;
-
-        ManualRulesOverride result;
-        result.rules = apply_rules_presets_and_overrides(
-            *preset_rules, resolved_path.parent_path(), g_alpine_server_config.base_rules,
-            std::format("rules preset alias '{}'", preset_name), &g_alpine_server_config.rules_preset_aliases,
-            nullptr, &applied_presets);
-
-        applied_presets.emplace_back(resolved_path, preset_name);
-        result.applied_preset_paths = std::move(applied_presets);
-        result.preset_alias = std::string(preset_name);
-        return result;
-    }
-    catch (const toml::parse_error& err) {
-        rf::console::print("  [ERROR] failed to parse rules preset alias '{}' at '{}': {}\n",
-            preset_name, resolved_path.generic_string(), err.description());
-        return std::nullopt;
-    }
-}
-
 static void add_level_entry_from_table(
     AlpineServerConfig& cfg,
     const toml::table& lvl_tbl,
-    const fs::path& base_dir,
     bool allow_missing_levels)
 {
     for (auto&& [k, v] : lvl_tbl) {
         const std::string key = std::string(k.str());
+        // rules_presets is a removed mechanic, accepted and ignored without complaint.
         if (key != "filename" && key != "rules" && key != "rules_presets") {
             xlog::warn("Unknown key '{}' inside a [[levels]] entry; did you intend to put it in [root]?", key);
         }
@@ -1137,62 +1029,13 @@ static void add_level_entry_from_table(
     AlpineServerConfigLevelEntry entry;
     entry.level_filename = tmp_filename;
 
-    std::string context = "level '" + (tmp_filename.empty() ? std::string("<unknown>") : tmp_filename) + "'";
-    entry.rule_overrides = apply_rules_presets_and_overrides(
-        lvl_tbl, base_dir, cfg.base_rules, context, &cfg.rules_preset_aliases, nullptr, &entry.applied_rules_preset_paths);
-    // Mutator-free variant, used as the starting point for level/match votes
-    // that carry mutators.
-    {
-        const RulesParseQuietGuard quiet;
-        entry.rule_overrides_no_mutators = apply_rules_presets_and_overrides(
-            lvl_tbl, base_dir, cfg.base_rules_no_mutators, context,
-            &cfg.rules_preset_aliases, nullptr, nullptr, /*apply_mutators*/ false);
-    }
+    entry.rule_overrides = parse_scope_rules(
+        lvl_tbl, cfg.base_rules,
+        RulesParseOptions{RulesParseMode::Full, &cfg.base_rules_keys_only});
 
     cfg.levels.push_back(std::move(entry));
 }
 
-static void apply_rules_preset_aliases(AlpineServerConfig& cfg, const toml::table& tbl, const fs::path& base_dir)
-{
-    for (auto&& [alias_key, node] : tbl) {
-        if (!node.is_value()) {
-            xlog::warn("rules_preset_aliases entry '{}' must be a string", alias_key.str());
-            continue;
-        }
-
-        auto alias_value = node.value<std::string>();
-        if (!alias_value) {
-            xlog::warn("rules_preset_aliases entry '{}' must be a string", alias_key.str());
-            continue;
-        }
-
-        fs::path resolved_path = base_dir / *alias_value;
-        try {
-            resolved_path = fs::weakly_canonical(resolved_path);
-        }
-        catch (const fs::filesystem_error& err) {
-            rf::console::print("  [WARN] failed to canonicalize rules preset alias '{}' -> '{}' : {}\n",
-                std::string(alias_key), *alias_value, err.what());
-            resolved_path = fs::absolute(resolved_path);
-        }
-
-        const std::string alias_name = static_cast<std::string>(alias_key.str());
-
-        auto it = cfg.rules_preset_aliases.find(alias_name);
-        if (it != cfg.rules_preset_aliases.end()) {
-            if (it->second == resolved_path)
-                continue;
-
-            it->second = resolved_path;
-            rf::console::print("  Updated rules preset alias '{}' -> {}\n", alias_name, resolved_path.generic_string());
-        }
-        else {
-            cfg.rules_preset_aliases.emplace(alias_name, resolved_path);
-            rf::console::print("  Registered rules preset alias '{}' -> {}\n", alias_name, resolved_path.generic_string());
-        }
-    }
-}
-
 static void parse_bot_config_table(ServerBotConfig& bot_cfg, const toml::table& tbl)
 {
     if (auto v = tbl["player_name"].value<std::string>()) {
@@ -1407,7 +1250,6 @@ static void apply_known_table_in_order(
     AlpineServerConfig& cfg,
     const std::string& key,
     const toml::table& tbl,
-    const fs::path& base_dir,
     bool allow_missing_levels)
 {
     if (key == "inactivity")
@@ -1440,19 +1282,18 @@ static void apply_known_table_in_order(
         cfg.vote_rand = parse_vote_config(tbl);
     else if (key == "vote_previous")
         cfg.vote_previous = parse_vote_config(tbl);
-    else if (key == "rules_preset_aliases")
-        apply_rules_preset_aliases(cfg, tbl, base_dir);
     else if (key == "base") {
-        cfg.base_rules = apply_rules_presets_and_overrides(
-            tbl, base_dir, cfg.base_rules, "base configuration", &cfg.rules_preset_aliases, nullptr, &cfg.base_rules_preset_paths);
+        cfg.base_rules = parse_scope_rules(tbl, cfg.base_rules);
         // Also compute the base rules with all mutators stripped, so a mutator applied
         // later via a level/match vote fully replaces (rather than stacks on top of)
         // whatever mutator the base rules declared.
         {
             const RulesParseQuietGuard quiet;
-            cfg.base_rules_no_mutators = apply_rules_presets_and_overrides(
-                tbl, base_dir, cfg.base_rules_no_mutators, "base configuration",
-                &cfg.rules_preset_aliases, nullptr, nullptr, /*apply_mutators*/ false);
+            cfg.base_rules_no_mutators = parse_scope_rules(
+                tbl, cfg.base_rules_no_mutators, RulesParseOptions{RulesParseMode::NoMutators});
+            // The only form replayable onto a DIFFERENT game type's defaults.
+            cfg.base_rules_keys_only = parse_scope_rules(
+                tbl, cfg.base_rules_keys_only, RulesParseOptions{RulesParseMode::KeysOnly});
         }
     }
     else if (key == "levels") {
@@ -1461,7 +1302,7 @@ static void apply_known_table_in_order(
                 if (!elem.is_table())
                     continue;
                 auto& lvl_tbl = *elem.as_table();
-                add_level_entry_from_table(cfg, lvl_tbl, base_dir, allow_missing_levels);
+                add_level_entry_from_table(cfg, lvl_tbl, allow_missing_levels);
             }
         }
     }
@@ -1472,7 +1313,6 @@ static void apply_known_array_in_order(
     AlpineServerConfig& cfg,
     const std::string& key,
     const toml::array& arr,
-    const fs::path& base_dir,
     bool allow_missing_levels)
 {
     if (key == "levels") {
@@ -1482,7 +1322,7 @@ static void apply_known_array_in_order(
 
             auto& lvl_tbl = *elem.as_table();
 
-            add_level_entry_from_table(cfg, lvl_tbl, base_dir, allow_missing_levels);
+            add_level_entry_from_table(cfg, lvl_tbl, allow_missing_levels);
         }
     }
     else if (key == "rcon_profiles") {
@@ -1548,11 +1388,11 @@ static void apply_config_table_in_order(
         if (auto* arr = v.as_array()) {
             if (key == "levels") {
                 if (pass == ParsePass::Levels)
-                    apply_known_array_in_order(cfg, key, *arr, base_dir, allow_missing_levels);
+                    apply_known_array_in_order(cfg, key, *arr, allow_missing_levels);
             }
             else if (key == "rcon_profiles") {
                 if (pass == ParsePass::Core)
-                    apply_known_array_in_order(cfg, key, *arr, base_dir, allow_missing_levels);
+                    apply_known_array_in_order(cfg, key, *arr, allow_missing_levels);
             }
             else if (key == "bot_profiles") {
                 if (pass == ParsePass::Core) {
@@ -1592,24 +1432,23 @@ static void apply_config_table_in_order(
             if (key == "levels") {
                 if (pass == ParsePass::Levels) {
                     if (auto nested = sub_tbl->as_array())
-                        apply_known_array_in_order(cfg, key, *nested, base_dir, allow_missing_levels);
+                        apply_known_array_in_order(cfg, key, *nested, allow_missing_levels);
                 }
                 continue;
             }
             if (key == "rcon_profiles") {
                 if (pass == ParsePass::Core) {
                     if (auto nested = sub_tbl->as_array())
-                        apply_known_array_in_order(cfg, key, *nested, base_dir, allow_missing_levels);
+                        apply_known_array_in_order(cfg, key, *nested, allow_missing_levels);
                 }
                 continue;
             }
-
             // allow root table workaround to allow root config after subsections in parent toml
             if (key == "root") {
                 apply_config_table_in_order(cfg, *sub_tbl, base_dir, pass, allow_missing_levels);
             }
             else {
-                apply_known_table_in_order(cfg, key, *sub_tbl, base_dir, allow_missing_levels);
+                apply_known_table_in_order(cfg, key, *sub_tbl, allow_missing_levels);
             }
 
             continue;
@@ -1624,7 +1463,8 @@ void load_ads_server_config(std::string ads_config_name, bool allow_missing_leve
     AlpineServerConfig cfg;     // start from defaults
 
     // Seed the game type defaults before parsing so an explicit game_type
-    // layers on top of them.
+    // layers on top of them. Not base_rules_keys_only, which must stay free of any
+    // game type's fields.
     apply_defaults_for_game_type(cfg.base_rules.game_type, cfg.base_rules);
     apply_defaults_for_game_type(cfg.base_rules_no_mutators.game_type, cfg.base_rules_no_mutators);
 
@@ -2193,25 +2033,6 @@ void print_rules(std::string& output, const AlpineServerConfigRules& rules, bool
         std::format_to(iter, "  GunGame final weapon:                  {}\n", rules.gungame_final_weapon);
 }
 
-void print_rules_with_presets(std::string& output, const AlpineServerConfigRules& rules, const std::vector<std::pair<std::filesystem::path, std::optional<std::string>>>& preset_paths, bool base, const bool remote = false)
-{
-    const auto iter = std::back_inserter(output);
-    if (!preset_paths.empty()) {
-        std::format_to(iter, "  Rules presets applied:\n");
-        for (const auto& [preset_path, preset_alias] : preset_paths) {
-            const std::string path = remote
-                ? preset_path.filename().generic_string()
-                : preset_path.generic_string();
-            if (preset_alias) {
-                std::format_to(iter, "    {} (alias '{}')\n", path, preset_alias.value());
-            } else {
-                std::format_to(iter, "    {}\n", path);
-            }
-        }
-    }
-    print_rules(output, rules, base);
-}
-
 std::string format_mutator_option_value(const MutatorOptionValue& value)
 {
     return std::visit([](const auto& v) -> std::string {
@@ -2448,25 +2269,14 @@ void print_alpine_dedicated_server_config_info(std::string& output, bool verbose
         }
     }
     
-    if (!cfg.rules_preset_aliases.empty()) {
-        std::format_to(iter, "\n---- Rules preset alias mappings ----\n");
-        for (const auto& [alias, path] : cfg.rules_preset_aliases) {
-            if (remote) {
-                std::format_to(iter, "  {} -> {}\n", alias, path.filename().generic_string());
-            } else {
-                std::format_to(iter, "  {} -> {}\n", alias, path.generic_string());
-            }
-        }
-    }
-
     std::format_to(iter, "\n---- Base rules ----\n");
-    print_rules_with_presets(output, cfg.base_rules, cfg.base_rules_preset_paths, true, remote);
+    print_rules(output, cfg.base_rules, true);
 
     std::format_to(iter, "\n---- Level rotation ----\n");
     for (size_t i = 0; i < cfg.levels.size(); ++i) {
         const auto& lvl = cfg.levels[i];
         std::format_to(iter, "{} ({})\n", lvl.level_filename, i);
-        print_rules_with_presets(output, lvl.rule_overrides, lvl.applied_rules_preset_paths, false, remote);
+        print_rules(output, lvl.rule_overrides, false);
     }
     std::format_to(iter, "\n");
 }
@@ -2585,26 +2395,24 @@ bool apply_game_type_for_current_level() {
     rf::NetGameType desired = rf::NetGameType::NG_TYPE_DM;
 
     if (manual_load) {
-        const AlpineServerConfigRules& manual_rules =
-            g_manual_rules_override ? g_manual_rules_override->rules : cfg.base_rules;
+        // Same resolution a vote for this level would get.
+        const rf::NetGameType level_default = g_manual_rules_override
+            ? g_manual_rules_override->rules.game_type
+            : resolve_level_default_game_type(rf::level_filename_to_load.c_str());
 
-        desired = has_already_queued_change ? upcoming : manual_rules.game_type;
+        desired = has_already_queued_change ? upcoming : level_default;
 
         if (!g_ads_minimal_server_info && !has_already_queued_change && desired != upcoming) {
             if (g_manual_rules_override && g_manual_rules_override->mutator_labels) {
                 rf::console::print("Applying voted mutators '{}' game type {} for manually loaded level {}...\n",
                     *g_manual_rules_override->mutator_labels, multi_game_type_name_short(desired), rf::level_filename_to_load);
             }
-            else if (g_manual_rules_override && g_manual_rules_override->preset_alias) {
-                rf::console::print("Applying rules preset '{}' game type {} for manually loaded level {}...\n",
-                    *g_manual_rules_override->preset_alias, multi_game_type_name_short(desired), rf::level_filename_to_load);
-            }
             else if (g_manual_rules_override) {
                 rf::console::print("Applying manual override game type {} for manually loaded level {}...\n",
                     multi_game_type_name_short(desired), rf::level_filename_to_load);
             }
             else {
-                rf::console::print("Applying base game type {} for manually loaded level {}...\n",
+                rf::console::print("Applying default game type {} for manually loaded level {}...\n",
                     multi_game_type_name_short(desired), rf::level_filename_to_load);
             }
         }
@@ -2671,18 +2479,18 @@ void apply_rules_for_current_level()
                 if (g_manual_rules_override->mutator_labels)
                     rf::console::print("Applying voted mutators '{}' for manually loaded level {}...\n",
                                        *g_manual_rules_override->mutator_labels, rf::level_filename_to_load);
-                else if (g_manual_rules_override->preset_alias)
-                    rf::console::print("Applying rules preset '{}' for manually loaded level {}...\n",
-                                       *g_manual_rules_override->preset_alias, rf::level_filename_to_load);
                 else
                     rf::console::print("Applying manual rules override for manually loaded level {}...\n",
                                        rf::level_filename_to_load);
             }
         }
         else {
-            g_alpine_server_config_active_rules = cfg.base_rules;
+            // Derives like a level vote that named nothing. Never a copy of the previous
+            // level's rules, which would carry its game type's fields over.
+            g_alpine_server_config_active_rules =
+                build_derived_server_rules(rf::netgame.type, cfg.base_rules.mutators.declarations);
             if (!g_ads_minimal_server_info)
-                rf::console::print("Applying base rules for manually loaded level {}...\n", rf::level_filename_to_load);
+                rf::console::print("Applying derived rules for manually loaded level {}...\n", rf::level_filename_to_load);
         }
     }
     else { // level is in rotation
@@ -2703,48 +2511,56 @@ void apply_rules_for_current_level()
     }
 
     // A rotation vote asked to carry the session's vote-set rules onto this level.
-    // Layered on top of the rules resolved above, then stored back as the session
-    // override so the config print reports it and a later preserve vote continues it.
+    // Derived from scratch, REPLACING the rules above, and stored back as the session
+    // override so a later preserve vote continues it.
     // Deliberately NOT via set_manual_rules_override(): that would also flag the
     // level as manually loaded and break the rotation cursor's semantics.
     if (get_pending_rotation_preserve()) {
         const PendingRotationPreserve pending = *get_pending_rotation_preserve();
         clear_pending_rotation_preserve();
 
-        auto carried = load_vote_rules_override(rf::level_filename_to_load.c_str(),
-                                                pending.declarations, pending.gametype);
-        if (carried) {
-            g_alpine_server_config_active_rules = carried->rules;
-            g_manual_rules_override = std::move(*carried);
-            if (!g_ads_minimal_server_info) {
-                rf::console::print("Carrying voted session rules onto {}...\n", rf::level_filename_to_load);
-            }
+        ManualRulesOverride carried = load_vote_rules_override(rf::level_filename_to_load.c_str(),
+                                                               pending.declarations, pending.gametype);
+        // A carried set was explicit where it was voted, and stays so here: a further
+        // preserve vote continues it.
+        carried.explicit_session = true;
+        g_alpine_server_config_active_rules = carried.rules;
+        g_manual_rules_override = std::move(carried);
+        if (!g_ads_minimal_server_info) {
+            rf::console::print("Carrying voted session rules onto {}...\n", rf::level_filename_to_load);
         }
     }
 
-    // respect game type specific base rules (eg. koth spawn loadout) for voted or manually loaded maps
+    // The rules above can still name a different game type than the level is starting
+    // under (sv_gametype on a rotation entry). Rebuilt, not retargeted: retargeting
+    // leaves fields only the old game type claimed in force.
     const rf::NetGameType active_game_type = rf::netgame.type;
     if (g_alpine_server_config_active_rules.game_type != active_game_type) {
-        // apply_defaults_for_game_type() rebuilds the loadout and clears MutatorConfig,
-        // so capture this scope's mutator declarations first and re-apply them on top
-        // of the new game-type defaults.
         const std::vector<MutatorDeclaration> saved_mutators =
             g_alpine_server_config_active_rules.mutators.declarations;
-
-        g_alpine_server_config_active_rules.game_type = active_game_type;
-        apply_defaults_for_game_type(active_game_type, g_alpine_server_config_active_rules);
-
-        if (!saved_mutators.empty()) {
-            const toml::array mut_arr = mutator_declarations_to_toml_array(saved_mutators);
-            apply_mutators_from_toml(mut_arr, g_alpine_server_config_active_rules);
+        g_alpine_server_config_active_rules =
+            build_derived_server_rules(active_game_type, saved_mutators);
+        if (g_manual_rules_override) {
+            g_manual_rules_override->rules = g_alpine_server_config_active_rules;
+            g_manual_rules_override->mutator_labels =
+                mutators_active_labels_string(g_alpine_server_config_active_rules);
         }
     }
 
     // apply the rules
     apply_alpine_dedicated_server_rules(netgame, g_alpine_server_config_active_rules);
 
-    // Signal consumers that the active rules were (re)applied this call.
+    // Must precede the blob rebuild below: the mutator registry caches its live-value
+    // defaults against this generation.
     ++g_active_rules_generation;
+
+    af_send_active_mutators_to_all();
+    // Rebuilt eagerly because the cfg-changed signal -- what makes every client
+    // re-request the blob -- is only worth raising when the bytes actually moved.
+    server_vote_invalidate_options_blob();
+    if (server_vote_refresh_options_blob()) {
+        cfg.signal_cfg_changed = true;
+    }
 }
 
 void init_alpine_dedicated_server() {
@@ -2835,7 +2651,7 @@ ConsoleCommand2 print_level_rules_cmd{
                     matches.push_back(i);
             }
             if (matches.empty()) {
-                rf::console::print("Level {} not found in rotation. If manually loaded, base rules would be used.\n", *maybe_filename);
+                rf::console::print("Level {} not found in rotation. If manually loaded, rules derived for its game type would be used.\n", *maybe_filename);
                 return;
             }
         } else {
@@ -2861,25 +2677,23 @@ ConsoleCommand2 print_level_rules_cmd{
                 if (g_manual_rules_override) {
                     if (g_manual_rules_override->mutator_labels)
                         rf::console::print("  (manually loaded {} is using voted mutators '{}')\n\n", rf::level_filename_to_load, *g_manual_rules_override->mutator_labels);
-                    else if (g_manual_rules_override->preset_alias)
-                        rf::console::print("  (manually loaded {} is using rules preset '{}')\n\n", rf::level_filename_to_load, *g_manual_rules_override->preset_alias);
                     else
                         rf::console::print("  (manually loaded {} has a manual rules override)\n\n", rf::level_filename_to_load);
                     std::string output{};
-                    print_rules_with_presets(output, g_manual_rules_override->rules, g_manual_rules_override->applied_preset_paths, true);
+                    print_rules(output, g_manual_rules_override->rules, true);
                     rf::console::print("{}", output.c_str());
                 }
                 else {
-                    rf::console::print("  (manually loaded {} is using base rules)\n\n", rf::level_filename_to_load);
+                    rf::console::print("  (manually loaded {} is using rules derived for its game type)\n\n", rf::level_filename_to_load);
                     std::string output{};
-                    print_rules_with_presets(output, cfg.base_rules, cfg.base_rules_preset_paths, true);
+                    print_rules(output, g_alpine_server_config_active_rules, true);
                     rf::console::print("{}", output.c_str());
                 }
             }
             else {
                 rf::console::print("\n---- Rules for level {} (index {}) ----\n", entry.level_filename, idx);
                 std::string output{};
-                print_rules_with_presets(output, entry.rule_overrides, entry.applied_rules_preset_paths, true);
+                print_rules(output, entry.rule_overrides, true);
                 rf::console::print("{}", output.c_str());
             }
         }
diff --git a/game_patch/multi/multi.cpp b/game_patch/multi/multi.cpp
index 55fc88d9a..fffb9873d 100644
--- a/game_patch/multi/multi.cpp
+++ b/game_patch/multi/multi.cpp
@@ -32,6 +32,7 @@
 #include "../os/os.h"
 #include "../os/console.h"
 #include "../misc/misc.h"
+#include "../misc/alpine_options.h"
 #include "../misc/alpine_settings.h"
 #include "../misc/waypoints.h"
 #include "../rf/os/os.h"
@@ -250,11 +251,14 @@ void handle_levelm_param()
 }
 
 // Returns true if -awpgen was handled (caller should skip -levelm).
+// This is the first point at which the flag can be set: the engine parses the command
+// line after the patch DLL's init runs, so `found()` is still false back there.
 bool handle_awpgen_param()
 {
-    if (!get_awpgen_cmd_line_param().found()) {
+    if (rf::is_dedicated_server || !get_awpgen_cmd_line_param().found()) {
         return false;
     }
+    g_awpgen_mode = true;
 
     const char* arg = get_awpgen_cmd_line_param().get_arg();
     if (!arg || arg[0] == '\0') {
@@ -1059,6 +1063,44 @@ std::string_view multi_game_type_prefix(const rf::NetGameType game_type) {
     }
 }
 
+// Strictly the prefix: the any-level rule and the RUN level list are the caller's.
+static bool multi_level_name_has_game_type_prefix(std::string_view level_filename, rf::NetGameType game_type)
+{
+    // UNK has no prefix of its own; multi_game_type_prefix answers "dm" for it.
+    if (game_type == rf::NG_TYPE_UNK) {
+        return false;
+    }
+    if (string_istarts_with(level_filename, multi_game_type_prefix(game_type))) {
+        return true;
+    }
+    if ((game_type == rf::NG_TYPE_DM || game_type == rf::NG_TYPE_TEAMDM)
+        && string_istarts_with(level_filename, "pdm")) {
+        return true;
+    }
+    if ((game_type == rf::NG_TYPE_CTF || game_type == rf::NG_TYPE_SAL)
+        && string_istarts_with(level_filename, "pctf")) {
+        return true;
+    }
+    return false;
+}
+
+// The game type a level filename's prefix names, or nullopt when it carries none.
+// Enum order decides a shared prefix (DM before TeamDM, CTF before SAL). The any-level
+// game types are skipped - this direction only, they still ACCEPT any mp level.
+std::optional<rf::NetGameType> multi_game_type_for_level_prefix(std::string_view level_filename)
+{
+    for (int i = 0; i < static_cast<int>(rf::NG_TYPE_UNK); ++i) {
+        const auto game_type = static_cast<rf::NetGameType>(i);
+        if (multi_game_type_uses_any_level(game_type)) {
+            continue;
+        }
+        if (multi_level_name_has_game_type_prefix(level_filename, game_type)) {
+            return game_type;
+        }
+    }
+    return std::nullopt;
+}
+
 // Game types that have no dedicated level-name prefix of their own and are
 // played on any standard MP level.
 bool multi_game_type_uses_any_level(rf::NetGameType game_type)
@@ -1084,6 +1126,23 @@ bool multi_level_name_matches_any_mp_prefix(const char* filename)
         || string_istarts_with(filename, "esc");
 }
 
+// "Can this game type be played on a level with this name?" The vote gate and the
+// blob's per-level mask both derive from here. resolve_level_default_game_type is NOT
+// bound by it and can answer outside the mask.
+bool multi_level_name_matches_game_type(std::string_view level_filename, rf::NetGameType game_type)
+{
+    const std::string map_name = normalize_level_filename(level_filename);
+
+    if (game_type == rf::NG_TYPE_RUN && is_known_run_level(map_name)) {
+        return true;
+    }
+    if (multi_game_type_uses_any_level(game_type)
+        && multi_level_name_matches_any_mp_prefix(map_name.c_str())) {
+        return true;
+    }
+    return multi_level_name_has_game_type_prefix(map_name, game_type);
+}
+
 // A level name with ".rfl" appended when it is missing.
 std::string normalize_level_filename(std::string_view name)
 {
@@ -1431,7 +1490,6 @@ void multi_do_patch()
     get_awpgen_cmd_line_param();
     g_client_bot_launch_enabled = is_client_bot_requested_from_cmdline() || is_client_debugbot_requested_from_cmdline();
     g_client_bot_debug_render_enabled = is_client_debugbot_requested_from_cmdline();
-    g_awpgen_mode = get_awpgen_cmd_line_param().found();
     if (is_headless_mode()) {
         g_alpine_game_config.rendering_enabled = false;
         rf::sound_enabled = false;
diff --git a/game_patch/multi/multi.h b/game_patch/multi/multi.h
index 6ccf569a0..6ede277e3 100644
--- a/game_patch/multi/multi.h
+++ b/game_patch/multi/multi.h
@@ -208,8 +208,14 @@ std::string_view multi_game_type_name(rf::NetGameType game_type);
 std::string_view multi_game_type_name_upper(rf::NetGameType game_type);
 std::string_view multi_game_type_name_short(rf::NetGameType game_type);
 std::string_view multi_game_type_prefix(rf::NetGameType game_type);
+// The inverse of multi_game_type_prefix: the game type a filename's prefix names.
+std::optional<rf::NetGameType> multi_game_type_for_level_prefix(std::string_view level_filename);
 bool multi_game_type_uses_any_level(rf::NetGameType game_type);
 bool multi_level_name_matches_any_mp_prefix(const char* filename);
+// Full acceptance test: the strict prefix, the quirks table's run maps and the
+// any-level game types. The predicate the vote gate and the vote blob's per-level
+// mask share; level default resolution can answer outside it (see multi.cpp).
+bool multi_level_name_matches_game_type(std::string_view level_filename, rf::NetGameType game_type);
 std::string normalize_level_filename(std::string_view name); // appends ".rfl" when it is missing
 [[nodiscard]] int multi_num_spawned_players();
 int get_semi_auto_fire_wait_override();
diff --git a/game_patch/multi/mutators.cpp b/game_patch/multi/mutators.cpp
index e72fd3bf3..566da8418 100644
--- a/game_patch/multi/mutators.cpp
+++ b/game_patch/multi/mutators.cpp
@@ -44,6 +44,7 @@
 #include "../main/main.h"
 #include "../hud/multi_spectate.h"
 #include "../misc/player.h"
+#include "../misc/alpine_options.h"
 #include "../misc/alpine_settings.h"
 
 // Spawn reserve for a no-clip "infinite ammo" weapon. Firing draws from reserve,
@@ -795,7 +796,7 @@ void apply_mutators_from_toml(const toml::array& mutators_arr, AlpineServerConfi
             def->apply(rules, it->second);
             labels.push_back(def->label);
         }
-        else {
+        else if (!g_rules_parse_quiet) {
             rf::console::print("  [WARN] mutator '{}' does nothing in this game type and was not applied\n", def->name);
         }
 
@@ -857,7 +858,8 @@ toml::array mutator_declarations_to_toml_array(const std::vector<MutatorDeclarat
 }
 
 std::optional<std::string> mutators_build_declarations_from_vote(
-    const std::vector<VoteMutatorInput>& input, std::vector<MutatorDeclaration>& out)
+    const std::vector<VoteMutatorInput>& input, rf::NetGameType game_type,
+    std::vector<MutatorDeclaration>& out)
 {
     out.clear();
 
@@ -870,6 +872,10 @@ std::optional<std::string> mutators_build_declarations_from_vote(
         if (!seen_ids.insert(entry.mutator_id).second) {
             return std::format("mutator '{}' was selected more than once", info->label);
         }
+        if (!mutator_gametype_mask_allows(info->valid_gametype_mask, static_cast<uint8_t>(game_type))) {
+            return std::format("mutator '{}' cannot be used in {}", info->label,
+                               multi_game_type_name_short(game_type));
+        }
 
         MutatorDeclaration decl;
         decl.name = info->name;
@@ -905,6 +911,11 @@ std::optional<std::string> mutators_build_declarations_from_vote(
                     decl.options[opt->name] = opt_in.int_value;
                     break;
                 case MutatorOptionType::Float:
+                    // Nothing downstream is prepared for a NaN or infinity off the wire.
+                    if (!std::isfinite(opt_in.float_value)) {
+                        return std::format("option '{}' of mutator '{}' has an out of range value",
+                                           opt->name, info->label);
+                    }
                     decl.options[opt->name] = opt_in.float_value;
                     break;
                 case MutatorOptionType::String:
@@ -957,14 +968,22 @@ static std::string mutator_vote_detail(const MutatorDef& def, const MutatorDecla
     return *str;
 }
 
-std::string mutators_join_labels(const std::vector<MutatorDeclaration>& declarations)
+static std::string join_labels(const std::vector<MutatorDeclaration>& declarations,
+                               std::optional<rf::NetGameType> game_type)
 {
     std::string joined;
     for (const auto& decl : declarations) {
+        const MutatorDef* def = find_mutator_by_name(decl.name);
+        // Same availability test apply_mutators_from_toml runs, so the line can never
+        // name a mutator the game type drops.
+        if (def && game_type
+            && !mutator_gametype_mask_allows(gametype_mask_for_req(def->gametype_req),
+                                             static_cast<uint8_t>(*game_type)))
+            continue;
+
         if (!joined.empty())
             joined += ", ";
 
-        const MutatorDef* def = find_mutator_by_name(decl.name);
         if (!def) {
             joined += decl.name;
             continue;
@@ -978,62 +997,100 @@ std::string mutators_join_labels(const std::vector<MutatorDeclaration>& declarat
     return joined;
 }
 
-const AlpineServerConfigRules& vote_natural_rules_for_level(std::string_view level_filename)
+std::string mutators_join_labels(const std::vector<MutatorDeclaration>& declarations,
+                                 std::optional<rf::NetGameType> game_type)
+{
+    return join_labels(declarations, game_type);
+}
+
+rf::NetGameType resolve_level_default_game_type(std::string_view level_filename)
 {
+    const std::string normalized = normalize_level_filename(level_filename);
+
     for (const auto& entry : g_alpine_server_config.levels) {
-        if (string_iequals(entry.level_filename, level_filename))
-            return entry.rule_overrides_no_mutators;
+        if (string_iequals(entry.level_filename, normalized))
+            return entry.rule_overrides.game_type;
     }
-    // Not in the rotation: a manually named level runs on the base rules.
-    return g_alpine_server_config.base_rules_no_mutators;
+
+    // Run maps carry no prefix, so the quirks table is the only thing that identifies
+    // them. Behind the rotation lookup, which the operator meant.
+    if (is_known_run_level(normalized))
+        return rf::NetGameType::NG_TYPE_RUN;
+
+    // Ahead of the prefix scan: the base game type gets the level if it can host it,
+    // so a TeamDM server keeps TeamDM for dm07 rather than the prefix's DM.
+    const rf::NetGameType base_gt = g_alpine_server_config.base_rules.game_type;
+    if (multi_level_name_matches_game_type(normalized, base_gt))
+        return base_gt;
+
+    if (auto from_prefix = multi_game_type_for_level_prefix(normalized))
+        return *from_prefix;
+
+    return base_gt;
 }
 
-std::optional<ManualRulesOverride> load_vote_rules_override(
-    std::string_view level_filename, const std::vector<MutatorDeclaration>& mutators,
-    std::optional<rf::NetGameType> gametype)
+AlpineServerConfigRules build_derived_server_rules(rf::NetGameType game_type,
+                                                   const std::vector<MutatorDeclaration>& mutators)
 {
-    if (mutators.empty() && !gametype)
-        return std::nullopt;
+    const auto& cfg = g_alpine_server_config;
+
+    // Nothing to derive: the fully layered base rules ARE the answer. Rebuilding would
+    // apply the mutators last and lose the keys-over-mutators layering.
+    if (game_type == cfg.base_rules.game_type && mutators == cfg.base_rules.mutators.declarations) {
+        return cfg.base_rules;
+    }
 
-    // Inheritance rule for a vote override, in layering order:
-    //   1. the rules the voted level would run with on its own — its rotation
-    //      entry's rules if it is in the rotation, otherwise the base rules —
-    //      with config-declared mutators stripped (voted mutators REPLACE
-    //      configured ones rather than stacking on them),
-    //   2. the voted game type and its gametype defaults, if one was voted,
-    //   3. the voted mutator declarations.
-    // Starting from the base rules instead (as this used to) silently dragged the
-    // base game type onto a level whose rotation entry overrides it, so adding a
-    // single mutator to a level vote could flip the whole game type.
-    AlpineServerConfigRules rules = vote_natural_rules_for_level(level_filename);
-
-    if (gametype && rules.game_type != *gametype) {
-        // Only re-derive the gametype defaults when the type actually CHANGES.
-        // apply_defaults_for_game_type() overwrites operator-configured rules
-        // (spawn loadout, pvp_damage_modifier, spawn_delay, ...), so explicitly
-        // voting the type a level already runs must behave the same as voting
-        // "Server default" rather than silently wiping the config. It also
-        // rebuilds the loadout and clears MutatorConfig, so mutators come after.
-        rules.game_type = *gametype;
-        apply_defaults_for_game_type(*gametype, rules);
+    // Every runtime derivation replays a set the config parse already reported on.
+    const RulesParseQuietGuard quiet;
+
+    AlpineServerConfigRules rules;
+    if (game_type == cfg.base_rules.game_type) {
+        // The operator's keys already sit on this game type's defaults in parse order.
+        rules = cfg.base_rules_no_mutators;
+    }
+    else {
+        // Never from another game type's materialized rules: they carry fields
+        // apply_defaults_for_game_type does not claim back.
+        rules = cfg.base_rules_keys_only;
+        rules.game_type = game_type;
+        apply_defaults_for_game_type(game_type, rules);
     }
 
+    // Applied AFTER the base keys, the reverse of the config parse: a voted layer has
+    // to win over what it was layered onto.
     if (!mutators.empty()) {
         const toml::array arr = mutator_declarations_to_toml_array(mutators);
         apply_mutators_from_toml(arr, rules);
     }
 
-    ManualRulesOverride result;
-    // Reported from what actually applied rather than from what was voted.
+    return rules;
+}
+
+std::optional<std::string> mutators_active_labels_string(const AlpineServerConfigRules& rules)
+{
     std::string labels;
     for (const auto& label : rules.mutators.active_labels) {
         if (!labels.empty())
             labels += ", ";
         labels += label;
     }
+    if (labels.empty())
+        return std::nullopt;
+    return labels;
+}
+
+ManualRulesOverride load_vote_rules_override(
+    std::string_view level_filename, const std::vector<MutatorDeclaration>& mutators,
+    std::optional<rf::NetGameType> gametype)
+{
+    const rf::NetGameType game_type = gametype.value_or(resolve_level_default_game_type(level_filename));
+
+    AlpineServerConfigRules rules = build_derived_server_rules(game_type, mutators);
+
+    ManualRulesOverride result;
+    // Reported from what actually applied rather than from what was voted.
+    result.mutator_labels = mutators_active_labels_string(rules);
     result.rules = std::move(rules);
-    if (!labels.empty())
-        result.mutator_labels = std::move(labels);
     return result;
 }
 
@@ -2619,7 +2676,7 @@ static void crits_play_fire_sound(const rf::Vector3& pos)
 // Defined with the rest of the telegraph below; the listen host drives them from the server side.
 static void crit_glow_add(int handle, const rf::gr::Color& color);
 static rf::gr::Color crit_glow_color_for(const rf::Player* pp);
-static void crits_flash_reticle();
+static void crits_flash_reticle(const rf::gr::Color& color);
 
 // The shooter's own client flashes its reticle for every crit fire event, whatever the weapon
 // class, so this goes out for hitscan, melee and the continuous window too - unlike the
@@ -2632,7 +2689,7 @@ static void crits_send_shot_to_shooter(rf::Player* shooter, int weapon_type)
         return;
     // A listen host's own packet would be discarded, so its flash is stamped directly.
     if (shooter == rf::local_player) {
-        crits_flash_reticle();
+        crits_flash_reticle(crit_glow_color_for(shooter));
     }
     else if (is_player_minimum_af_client_version(shooter, 1, 4, 0)) {
         af_send_crit_shot_packet(shooter->net_data->player_id,
@@ -2722,7 +2779,6 @@ static constexpr rf::gr::Color CRIT_GLOW_COLOR_NEUTRAL{255, 144, 32};
 // gives on the screen that fired it, so it covers every weapon class.
 static constexpr int64_t CRIT_RETICLE_FLASH_MS = 350;
 static constexpr int CRIT_RETICLE_FLASH_SIZE = 96; // ~3x the stock reticle bitmap
-static constexpr rf::gr::Color CRIT_RETICLE_FLASH_COLOR{255, 96, 32};
 static constexpr rf::gr::Mode CRIT_RETICLE_FLASH_MODE{
     rf::gr::TEXTURE_SOURCE_CLAMP,
     rf::gr::COLOR_SOURCE_VERTEX_TIMES_TEXTURE,
@@ -2731,7 +2787,14 @@ static constexpr rf::gr::Mode CRIT_RETICLE_FLASH_MODE{
     rf::gr::ZBUFFER_TYPE_NONE,
     rf::gr::FOG_NOT_ALLOWED,
 };
-static int64_t g_crit_reticle_flash_at = 0;
+// Colour resolved when the flash is stamped, not when it is drawn: a first person
+// spectator flashes in the shooter's colour rather than its own.
+struct CritReticleFlash
+{
+    int64_t at = 0;
+    rf::gr::Color color = CRIT_GLOW_COLOR_NEUTRAL;
+};
+static CritReticleFlash g_crit_reticle_flash;
 
 struct CritShotMarker
 {
@@ -2772,9 +2835,9 @@ static void crit_glow_add(int handle, const rf::gr::Color& color)
     g_crit_glows.push_back({handle, color});
 }
 
-static void crits_flash_reticle()
+static void crits_flash_reticle(const rf::gr::Color& color)
 {
-    g_crit_reticle_flash_at = timer::get_i64(1000);
+    g_crit_reticle_flash = {timer::get_i64(1000), color};
 }
 
 // The engine's own projectile head glow texture.
@@ -2803,7 +2866,7 @@ void crits_on_crit_shot(uint8_t shooter_player_id, uint8_t weapon_type)
     const bool spectating_shooter = !self && multi_spectate_is_first_person()
         && multi_spectate_get_target_player() == shooter;
     if (self || spectating_shooter)
-        crits_flash_reticle();
+        crits_flash_reticle(color);
 
     // Everything below telegraphs a projectile in flight; a hitscan, melee or flame crit has
     // none, and the flash above is its whole story. The shooter and anyone spectating it are
@@ -2896,16 +2959,16 @@ void crits_client_render()
 // HUD and never runs outside multiplayer gameplay.
 void crits_client_render_reticle_flash()
 {
-    if (!g_crit_reticle_flash_at || !g_alpine_game_config.crit_reticle_flash)
+    if (!g_crit_reticle_flash.at || !g_alpine_game_config.crit_reticle_flash)
         return;
-    const int64_t elapsed = timer::get_i64(1000) - g_crit_reticle_flash_at;
+    const int64_t elapsed = timer::get_i64(1000) - g_crit_reticle_flash.at;
     if (elapsed < 0 || elapsed >= CRIT_RETICLE_FLASH_MS) {
-        g_crit_reticle_flash_at = 0;
+        g_crit_reticle_flash = {};
         return;
     }
     const int glow_bitmap = crit_glow_bitmap();
     if (glow_bitmap < 0) {
-        g_crit_reticle_flash_at = 0;
+        g_crit_reticle_flash = {};
         return;
     }
     int bm_w = 0, bm_h = 0;
@@ -2916,8 +2979,8 @@ void crits_client_render_reticle_flash()
     const float fade = 1.0f - static_cast<float>(elapsed) / CRIT_RETICLE_FLASH_MS;
     const int x = (rf::gr::clip_width() - CRIT_RETICLE_FLASH_SIZE) / 2;
     const int y = (rf::gr::clip_height() - CRIT_RETICLE_FLASH_SIZE) / 2;
-    rf::gr::set_color(CRIT_RETICLE_FLASH_COLOR.red, CRIT_RETICLE_FLASH_COLOR.green,
-        CRIT_RETICLE_FLASH_COLOR.blue, static_cast<rf::ubyte>(fade * 255.0f));
+    const rf::gr::Color& color = g_crit_reticle_flash.color;
+    rf::gr::set_color(color.red, color.green, color.blue, static_cast<rf::ubyte>(fade * 255.0f));
     rf::gr::bitmap_scaled(glow_bitmap, x, y, CRIT_RETICLE_FLASH_SIZE, CRIT_RETICLE_FLASH_SIZE,
         0, 0, bm_w, bm_h, false, false, CRIT_RETICLE_FLASH_MODE);
 }
@@ -3121,7 +3184,7 @@ static void crits_reset()
     g_crit_shot_markers.clear();
     g_crit_glows.clear();
     g_crit_local_shots.clear();
-    g_crit_reticle_flash_at = 0;
+    g_crit_reticle_flash = {};
 }
 
 // The universal fire function: the listen host's own trigger, bots, and every remote
diff --git a/game_patch/multi/mutators.h b/game_patch/multi/mutators.h
index e1832edb2..f7b709891 100644
--- a/game_patch/multi/mutators.h
+++ b/game_patch/multi/mutators.h
@@ -8,8 +8,6 @@
 #include <toml++/toml.hpp>
 #include "server_internal.h"
 
-struct AlpineServerConfigRules;
-
 namespace rf
 {
     struct Entity;
@@ -228,20 +226,34 @@ toml::array mutator_declarations_to_toml_array(const std::vector<MutatorDeclarat
 
 // Validate packet-supplied mutator selections against the registry and turn them
 // into declarations. Returns an error string on failure, std::nullopt on success.
+// `game_type` is the type the vote would actually run under; a mutator not valid for
+// it is rejected. Explicit wire selections only - an inherited set must keep crossing
+// game types.
 std::optional<std::string> mutators_build_declarations_from_vote(
-    const std::vector<VoteMutatorInput>& input, std::vector<MutatorDeclaration>& out);
+    const std::vector<VoteMutatorInput>& input, rf::NetGameType game_type,
+    std::vector<MutatorDeclaration>& out);
+
+// Labels of the declared mutators, joined with ", ". Passing a game type drops the
+// declarations it would filter out at application time.
+std::string mutators_join_labels(const std::vector<MutatorDeclaration>& declarations,
+                                 std::optional<rf::NetGameType> game_type = std::nullopt);
+
+// Labels of the mutators these rules actually put in force, or nullopt when none did.
+// Every ManualRulesOverride label line derives from here.
+std::optional<std::string> mutators_active_labels_string(const AlpineServerConfigRules& rules);
 
-// Human-readable labels of the declared mutators, joined with ", ".
-std::string mutators_join_labels(const std::vector<MutatorDeclaration>& declarations);
+// The game type a level runs under when nothing names one, in precedence order: its
+// rotation entry's type, else Run for a quirks-table run map, else the base type if it
+// can host the level, else the filename prefix's type, else the base type.
+rf::NetGameType resolve_level_default_game_type(std::string_view level_filename);
 
-// The rules `level_filename` would run with if no vote were involved: its
-// rotation entry's rules when it is in the rotation, otherwise the base rules —
-// in both cases with config-declared mutators stripped.
-const AlpineServerConfigRules& vote_natural_rules_for_level(std::string_view level_filename);
+// Rules for `game_type` built without inheriting any other game type's fields.
+// `mutators` is applied last, in MUTATOR_APPLY_ORDER.
+AlpineServerConfigRules build_derived_server_rules(rf::NetGameType game_type,
+                                                   const std::vector<MutatorDeclaration>& mutators);
 
-// Build the rules a level/match vote should install: the voted level's natural
-// rules (above), optionally re-based on a voted game type plus that type's
-// defaults, then the voted mutators applied in MUTATOR_APPLY_ORDER.
-std::optional<ManualRulesOverride> load_vote_rules_override(
+// Rules a level/match vote (or a manual level load) installs. `gametype` falls back
+// to resolve_level_default_game_type.
+ManualRulesOverride load_vote_rules_override(
     std::string_view level_filename, const std::vector<MutatorDeclaration>& mutators,
     std::optional<rf::NetGameType> gametype);
diff --git a/game_patch/multi/salvage.cpp b/game_patch/multi/salvage.cpp
index 40696c3e2..bd415f56c 100644
--- a/game_patch/multi/salvage.cpp
+++ b/game_patch/multi/salvage.cpp
@@ -78,6 +78,7 @@ struct SalFlagSpawnEntry { const char* rfl; float x, y, z; };
 constexpr SalFlagSpawnEntry kSalFlagSpawnPositions[] = {
     { "pctf01.rfl", -0.01f, -0.16f, 19.04f },
     { "pctf02.rfl", 109.0f, 1.0f, 0.0f },
+    { "pctf03.rfl", -27.09f, 9.35f, -23.53f },
     { "ctf03.rfl", 3.76f, -5.47f, 0.13f },
     { "ctf06.rfl", 0.56f, -0.05f, -0.02f },
     { "ctf07.rfl", 8.50f, -5.25f, 9.25f },
diff --git a/game_patch/multi/server.cpp b/game_patch/multi/server.cpp
index 3e789bbf6..1ee37ae85 100644
--- a/game_patch/multi/server.cpp
+++ b/game_patch/multi/server.cpp
@@ -3452,6 +3452,9 @@ void server_reliable_socket_ready(rf::Player* player)
 
     // bring a player who joined during a vote up to date (AF 1.4+ only)
     server_vote_send_state_to_new_player(player);
+    // the vote panel pre-selects the session's mutator set, which is not in the
+    // (config-derived) vote options blob
+    af_send_active_mutators(player);
 
     // alert alpine clients to the queued match on join
     if (g_match_info.pre_match_active && player->version_info.software == ClientSoftware::AlpineFaction) {
diff --git a/game_patch/multi/server_internal.h b/game_patch/multi/server_internal.h
index c38fff07c..de4b82cda 100644
--- a/game_patch/multi/server_internal.h
+++ b/game_patch/multi/server_internal.h
@@ -940,12 +940,6 @@ struct AlpineServerConfigLevelEntry
 {
     std::string level_filename;
     AlpineServerConfigRules rule_overrides;
-    // The same rules re-resolved with every config-declared mutator stripped.
-    // Starting point for a level/match vote that carries mutators, so the voted
-    // mutators replace (rather than stack on) whatever the config declared while
-    // the rest of this level's rules — notably its game type — are preserved.
-    AlpineServerConfigRules rule_overrides_no_mutators;
-    std::vector<std::pair<std::filesystem::path, std::optional<std::string>>> applied_rules_preset_paths;
 };
 
 struct AlpineRconProfile
@@ -1031,8 +1025,9 @@ struct AlpineServerConfig
     // for a mutator applied via a level/match vote, so the voted mutator replaces
     // (rather than stacks on) any mutator the base rules declared.
     AlpineServerConfigRules base_rules_no_mutators;
-    std::vector<std::pair<std::filesystem::path, std::optional<std::string>>> base_rules_preset_paths;
-    std::map<std::string, std::filesystem::path> rules_preset_aliases;
+    // The operator's explicit base keys over struct defaults and NOTHING else. Rules
+    // for any other game type are built from this, so nothing can leak in.
+    AlpineServerConfigRules base_rules_keys_only;
     std::vector<AlpineServerConfigLevelEntry> levels;
 
     std::string printed_cfg{};
@@ -1073,11 +1068,11 @@ struct AlpineServerConfig
 struct ManualRulesOverride
 {
     AlpineServerConfigRules rules;
-    std::vector<std::pair<std::filesystem::path, std::optional<std::string>>> applied_preset_paths;
-    // Mutually exclusive: an override comes either from a named rules preset or
-    // from voted mutators, and the two are described differently to operators.
-    std::optional<std::string> preset_alias;
     std::optional<std::string> mutator_labels;
+    // The vote that installed this named a game type or submitted its own mutator
+    // set. A plain vote installs derived rules too, but arms no session set, so a
+    // rotation preserve vote after one carries nothing.
+    bool explicit_session = false;
 };
 
 struct MatchInfo
@@ -1134,6 +1129,18 @@ extern AFGameInfoFlags g_game_info_server_flags;
 extern std::string g_prev_level;
 extern bool g_is_overtime;
 extern MatchInfo g_match_info;
+// Set while rules are re-parsed or re-derived over a scope the config's own Full pass
+// already reported on; that pass is the one that reports problems.
+extern bool g_rules_parse_quiet;
+
+struct RulesParseQuietGuard
+{
+    bool previous;
+    RulesParseQuietGuard() : previous(g_rules_parse_quiet) { g_rules_parse_quiet = true; }
+    ~RulesParseQuietGuard() { g_rules_parse_quiet = previous; }
+    RulesParseQuietGuard(const RulesParseQuietGuard&) = delete;
+    RulesParseQuietGuard& operator=(const RulesParseQuietGuard&) = delete;
+};
 
 enum class UpcomingGameTypeSelection {
     Rotation,
@@ -1169,13 +1176,18 @@ void server_vote_handle_options_request(rf::Player* sender, bool has_cache, uint
 // discard a stream that was superseded mid-flight.
 const std::vector<uint8_t>& server_vote_get_options_blob(uint32_t& generation);
 void server_vote_invalidate_options_blob();
+// Rebuild the blob if invalid and report whether the bytes actually changed. The build
+// is content-addressed, so most invalidations answer false.
+bool server_vote_refresh_options_blob();
+// The mutator set currently in force, in the options blob's declaration-set encoding.
+// Session state, not config, so it is pushed separately from that blob.
+void server_vote_build_active_mutators_blob(std::vector<uint8_t>& blob);
 void vote_level_refresh_allowed_maps();
 // Push the current vote state to a player who joined while a vote is running.
 void server_vote_send_state_to_new_player(rf::Player* player);
 void handle_player_set_handicap(rf::Player* player, uint8_t amount);
 std::vector<rf::Player*> get_clients(bool include_browsers, bool include_bots);
 std::pair<bool, std::string> is_level_name_valid(std::string_view level_name_input);
-std::optional<ManualRulesOverride> load_rules_preset_alias(std::string_view preset_name);
 void set_manual_rules_override(ManualRulesOverride override_rules);
 void clear_manual_rules_override();
 void set_pending_rotation_preserve(PendingRotationPreserve pending);
diff --git a/game_patch/multi/vote_client.cpp b/game_patch/multi/vote_client.cpp
index f23613a2b..4607cc141 100644
--- a/game_patch/multi/vote_client.cpp
+++ b/game_patch/multi/vote_client.cpp
@@ -3,9 +3,12 @@
 #include <string_view>
 #include <utility>
 #include <xlog/xlog.h>
+#include <common/utils/string-utils.h>
 #include "vote_client.h"
 #include "alpine_packets.h"
+#include "multi.h"
 #include "../hud/hud.h"
+#include "../misc/alpine_options.h"
 #include "../misc/alpine_settings.h"
 #include "../os/os.h"
 #include "../rf/multi.h"
@@ -41,6 +44,10 @@ struct VoteOptionsCache
 VoteOptionsCache g_vote_options;
 std::optional<ActiveVoteState> g_active_vote;
 
+// Session mutator set pushed by the server (af_sreq_active_mutators).
+std::optional<std::vector<VoteMutatorDecl>> g_active_mutators;
+uint32_t g_active_mutators_revision = 0;
+
 // Retry interval while we have no blob at all. Once one is loaded a stale marker
 // costs exactly one request, so this only paces the initial fetch.
 constexpr int64_t vote_options_request_cooldown_ms = 3000;
@@ -442,6 +449,8 @@ bool parse_vote_options_blob(const uint8_t* data, size_t len, VoteOptionsData& o
         VoteLevelInfo level;
         level.filename = body.str();
         level.natural_gametype = body.u8();
+        // Taken as sent: adding local knowledge would make the panel offer what a
+        // differently-configured server will refuse.
         level.valid_gametype_mask = body.u32();
         level.allowed_for_vote = (body.u8() & AF_VOTE_LEVEL_FLAG_ALLOWED) != 0;
         // Read the entry's own success BEFORE the appended baseline set below, so
@@ -474,12 +483,40 @@ bool parse_vote_options_blob(const uint8_t* data, size_t len, VoteOptionsData& o
         r.skip(body_len); // unconditional: the next entry starts here either way
     }
 
-    // The base mutator set, appended after the level section. Failing to read it
-    // costs the vote panel's pre-selection and nothing else, so it never fails the
-    // blob: a blob from a server built before it existed simply ends here.
-    if (r.remaining() > 0 && !parse_declaration_set(r, parsed.base_mutator_decls)) {
-        xlog::debug("vote options: unparseable base mutator set; the vote panel will pre-select nothing");
-        parsed.base_mutator_decls.clear();
+    // The base mutator set, appended after the level section behind its own u16 length.
+    // Never fails the blob: a server built before it existed simply ends here, and
+    // `present` stays false, keeping "base runs nothing" distinct from "base unknown".
+    // Version-gated, not just length-gated: version 1 wrote these bytes as a bare
+    // declaration set, so its first two are not a length prefix.
+    bool base_section_consumed = false;
+    if (version >= 2 && r.remaining() > 0) {
+        const uint16_t base_len = r.u16();
+        if (!r.ok() || base_len > r.remaining()) {
+            xlog::debug("vote options: truncated base mutator section; the vote panel will pre-select nothing");
+        }
+        else {
+            BlobReader body{r.cur(), base_len};
+            if (parse_declaration_set(body, parsed.base_mutator_decls) && body.ok()) {
+                parsed.base_mutator_decls_present = true;
+            }
+            else {
+                xlog::debug("vote options: unparseable base mutator set; the vote panel will pre-select nothing");
+                parsed.base_mutator_decls.clear();
+            }
+            r.skip(base_len);
+            base_section_consumed = true;
+        }
+    }
+
+    // The base rules' game type. Gated on having CONSUMED the section above, not on the
+    // version alone: only then is the read position known to sit at this byte.
+    if (base_section_consumed && r.remaining() > 0) {
+        const uint8_t base_game_type = r.u8();
+        // Range checked: `present` must never be set to something unanswerable.
+        if (r.ok() && base_game_type < static_cast<uint8_t>(rf::NG_TYPE_UNK)) {
+            parsed.base_game_type = base_game_type;
+            parsed.base_game_type_present = true;
+        }
     }
 
     // Anything left over is a section a newer server appended; ignored on purpose.
@@ -532,11 +569,40 @@ uint32_t vote_options_loaded_generation()
     return g_vote_options.loaded_generation;
 }
 
+const std::vector<VoteMutatorDecl>* vote_active_mutators_get()
+{
+    return g_active_mutators ? &*g_active_mutators : nullptr;
+}
+
+uint32_t vote_active_mutators_revision()
+{
+    return g_active_mutators_revision;
+}
+
+void vote_active_mutators_on_received(const uint8_t* data, size_t len)
+{
+    BlobReader r{data, len};
+    std::vector<VoteMutatorDecl> decls;
+    if (!parse_declaration_set(r, decls)) {
+        xlog::warn("vote options: unparseable active mutator set ({} bytes); keeping the previous one", len);
+        return;
+    }
+    // An empty set is meaningful: "the session runs no mutators".
+    g_active_mutators = std::move(decls);
+    ++g_active_mutators_revision;
+}
+
 bool vote_level_allows_gametype(const VoteLevelInfo& level, uint8_t game_type)
 {
     if (game_type >= 32) {
         return false;
     }
+    // Mirrors is_level_valid_for_vote_gametype: the server accepts a level's own
+    // default even when it sits outside the prefix mask, so offering it here is
+    // what keeps "callable" and "accepted" the same answer.
+    if (game_type == level.natural_gametype) {
+        return true;
+    }
     return (level.valid_gametype_mask & (1u << game_type)) != 0;
 }
 
@@ -545,6 +611,69 @@ bool vote_level_allows_default_gametype(const VoteLevelInfo& level)
     return vote_level_allows_gametype(level, level.natural_gametype);
 }
 
+uint8_t vote_default_gametype_for_level(const VoteOptionsData& options, std::string_view level_string)
+{
+    const auto running = rf::multi_get_game_type();
+    if (level_string.empty()) {
+        return static_cast<uint8_t>(running);
+    }
+
+    const std::string wanted = normalize_level_filename(level_string);
+    // A listed level carries the server's own resolution, already reconciled with the
+    // mask sent beside it.
+    for (const auto& entry : options.levels) {
+        if (string_iequals(entry.filename, wanted)) {
+            return entry.natural_gametype;
+        }
+    }
+
+    // Unlisted name: mirror resolve_level_default_game_type step for step. A server too
+    // old to send a base game type leaves the running one standing in.
+    const rf::NetGameType base = options.base_game_type_present
+        ? static_cast<rf::NetGameType>(options.base_game_type)
+        : running;
+    if (is_known_run_level(wanted)) {
+        return static_cast<uint8_t>(rf::NetGameType::NG_TYPE_RUN);
+    }
+    if (multi_level_name_matches_game_type(wanted, base)) {
+        return static_cast<uint8_t>(base);
+    }
+    if (auto from_prefix = multi_game_type_for_level_prefix(wanted)) {
+        return static_cast<uint8_t>(*from_prefix);
+    }
+    return static_cast<uint8_t>(base);
+}
+
+uint8_t vote_match_current_level_gametype(const VoteOptionsData& options)
+{
+    const auto running = static_cast<uint8_t>(rf::multi_get_game_type());
+    const auto team_dm = static_cast<uint8_t>(rf::NG_TYPE_TEAMDM);
+
+    const VoteGametypeInfo* first_team = nullptr;
+    bool offers_team_dm = false;
+    for (const auto& entry : options.gametypes) {
+        if (!entry.is_team_type) {
+            continue; // a match cycler only offers team types
+        }
+        if (entry.id == running) {
+            return running;
+        }
+        if (entry.id == team_dm) {
+            offers_team_dm = true;
+        }
+        if (!first_team) {
+            first_team = &entry;
+        }
+    }
+
+    if (running == static_cast<uint8_t>(rf::NG_TYPE_DM) && offers_team_dm) {
+        return team_dm;
+    }
+    // Nothing offered at all leaves it to the server, exactly as an empty cycler
+    // makes the panel send "none".
+    return first_team ? first_team->id : af_vote_gametype_none;
+}
+
 bool vote_options_is_type_enabled(AfVoteType type)
 {
     // Deliberately keyed on `loaded` alone, matching vote_options_are_loaded():
@@ -804,6 +933,8 @@ void vote_client_reset()
     // Drops any partial stream along with the parsed cache: the accumulated bytes
     // belong to the server we just left.
     g_vote_options = VoteOptionsCache{};
+    g_active_mutators.reset();
+    g_active_mutators_revision = 0;
     // Also drop the HUD prompt: without this a vote left running on the server we
     // just left would keep its notification up across a reconnect elsewhere.
     remove_hud_vote_notification();
diff --git a/game_patch/multi/vote_client.h b/game_patch/multi/vote_client.h
index d49d9aeac..08c0401db 100644
--- a/game_patch/multi/vote_client.h
+++ b/game_patch/multi/vote_client.h
@@ -61,9 +61,8 @@ struct VoteMutatorDeclValue
     std::string string_value;
 };
 
-// One config-declared mutator. The panel pre-selects these so that submitting an
-// untouched vote reproduces what the level would run anyway (votes replace the
-// configured mutator set rather than stacking on it).
+// One declared mutator and its values: the shape of every declaration set the server
+// sends. A vote REPLACES the mutator set rather than stacking on it.
 struct VoteMutatorDecl
 {
     uint8_t mutator_id = 0;
@@ -73,7 +72,7 @@ struct VoteMutatorDecl
 struct VoteLevelInfo
 {
     std::string filename;
-    // Game type this level runs with when the vote picks "Server default".
+    // The level's own game type: what it runs under when a vote names none.
     uint8_t natural_gametype = 0; // rf::NetGameType
     // bit N (matching NetGameType N) = this level matches that game type's level
     // prefix rules.
@@ -100,17 +99,37 @@ struct VoteOptionsData
     std::vector<VoteGametypeInfo> gametypes;
     std::vector<VoteMutatorSchema> mutators;
     std::vector<VoteLevelInfo> levels; // rotation order, then vote-allowed extras
-    // Mutators the server's base rules declare; the baseline for every level that
-    // does not carry its own. Empty for a server built before the blob carried it.
+    // What the panel's "Base" button applies, and the baseline on a server too old to
+    // push an active set.
     std::vector<VoteMutatorDecl> base_mutator_decls;
+    // Whether the blob carried that section: "base declares none" is not "base unknown".
+    bool base_mutator_decls_present = false;
+    // The base rules' game type: the fallback for a name nothing else claims. Absent
+    // from a server built before the blob carried it.
+    uint8_t base_game_type = 0; // rf::NetGameType
+    bool base_game_type_present = false;
 };
 
-// Does this level match the given game type's level prefix rules? Whether that
-// is a hard restriction depends on VoteOptionsData::gametype_prefix_restricted.
+// Would the server accept this level voted with this game type? Its prefix rules,
+// plus the level's own default, which the server always accepts. Whether that is a
+// hard restriction depends on VoteOptionsData::gametype_prefix_restricted.
 bool vote_level_allows_gametype(const VoteLevelInfo& level, uint8_t game_type);
-// Same, for the "Server default" (no gametype override) selection.
+// Same, against the level's own game type, for a vote that names none.
 bool vote_level_allows_default_gametype(const VoteLevelInfo& level);
 
+// The game type a vote naming none resolves to: the level's own byte when the server
+// listed it, else its resolution order replayed against the blob's base game type. An
+// empty name answers with what is running here (Match's "current level"). The single
+// client-side answer, so the panel and the saved-vote check agree.
+uint8_t vote_default_gametype_for_level(const VoteOptionsData& options, std::string_view level_string);
+
+// The game type a Match vote on the CURRENT level resolves to: what the session is
+// running, put through the match game type cycler's team-only remap (DM becomes
+// TeamDM when the server offers it, otherwise the first team type offered; none when
+// it offers no team type at all). The single answer for both the panel's "Current
+// level" row and a saved Match record with no level, so both send the same byte.
+uint8_t vote_match_current_level_gametype(const VoteOptionsData& options);
+
 struct ActiveVoteState
 {
     // The RAW wire byte, deliberately NOT an AfVoteType: a newer server may run a
@@ -154,6 +173,13 @@ bool vote_options_is_type_enabled(AfVoteType type);
 void vote_options_request_if_needed();
 void vote_options_mark_stale();
 
+// --- active mutator set (af_sreq_active_mutators) ---
+// What the session is running right now. `nullptr` until the server sends one.
+const std::vector<VoteMutatorDecl>* vote_active_mutators_get();
+// Bumped on every push; 0 means nothing received yet.
+uint32_t vote_active_mutators_revision();
+void vote_active_mutators_on_received(const uint8_t* data, size_t len);
+
 // Blob stream (af_sreq_vote_options_data). Ordered reliable delivery, so Begin ->
 // Data* -> End arrive in that order; anything out of order is a protocol error and
 // discards the stream.
diff --git a/game_patch/multi/votes.cpp b/game_patch/multi/votes.cpp
index 4863876b8..d5840d384 100644
--- a/game_patch/multi/votes.cpp
+++ b/game_patch/multi/votes.cpp
@@ -17,7 +17,6 @@
 #include "../rf/misc.h"
 #include "../rf/os/timestamp.h"
 #include "../os/console.h"
-#include "../misc/alpine_options.h"
 #include "../misc/player.h"
 #include "../main/main.h"
 #include <common/utils/list-utils.h>
@@ -547,41 +546,6 @@ struct Vote
     }
 };
 
-static bool does_level_match_gametype_prefix(const std::string& level_name, rf::NetGameType game_type)
-{
-    const std::string map_name = normalize_level_filename(level_name);
-
-    if (game_type == rf::NG_TYPE_RUN && is_known_run_level(level_name)) {
-        return true;
-    }
-
-    // Accept any standard MP level.
-    if (multi_game_type_uses_any_level(game_type)
-        && multi_level_name_matches_any_mp_prefix(map_name.c_str())) {
-        return true;
-    }
-
-    const auto base_prefix = multi_game_type_prefix(game_type);
-
-    auto matches_prefix = [&](std::string_view prefix) {
-        return string_istarts_with(map_name, prefix);
-    };
-
-    if (matches_prefix(base_prefix)) {
-        return true;
-    }
-
-    if ((game_type == rf::NG_TYPE_DM || game_type == rf::NG_TYPE_TEAMDM) && matches_prefix("pdm")) {
-        return true;
-    }
-
-    if ((game_type == rf::NG_TYPE_CTF || game_type == rf::NG_TYPE_SAL) && matches_prefix("pctf")) {
-        return true;
-    }
-
-    return false;
-}
-
 // The union of the rotation and the vote-allowed list, in rotation order, with
 // case-insensitive dedup. Also what the vote-options blob advertises.
 static std::vector<std::string> build_votable_level_list()
@@ -610,23 +574,6 @@ static std::vector<std::string> build_votable_level_list()
     return levels;
 }
 
-// The game type the voted level will actually run with, mirroring
-// load_vote_rules_override's inheritance: a voted game type wins; otherwise a
-// vote that builds an override rebases onto the level's natural rules, and a
-// vote that builds no override leaves the level running exactly as it is.
-static rf::NetGameType resolve_effective_vote_game_type(const std::string& level_name,
-                                                        std::optional<rf::NetGameType> gametype,
-                                                        bool builds_override, bool keeps_current_level)
-{
-    if (gametype) {
-        return *gametype;
-    }
-    if (!builds_override && keeps_current_level) {
-        return g_alpine_server_config_active_rules.game_type;
-    }
-    return vote_natural_rules_for_level(level_name).game_type;
-}
-
 // Enforcement-aware answer to "would the server accept this level voted with this
 // game type?" — the call-time validation gate. A server with
 // only_allow_gametype_prefix off accepts everything.
@@ -635,7 +582,11 @@ static bool is_level_valid_for_vote_gametype(const std::string& level_name, rf::
     if (!g_alpine_server_config.vote_level.only_allow_gametype_prefix) {
         return true;
     }
-    return does_level_match_gametype_prefix(level_name, game_type);
+    // A level's own resolved default is always acceptable.
+    if (game_type == resolve_level_default_game_type(level_name)) {
+        return true;
+    }
+    return multi_level_name_matches_game_type(level_name, game_type);
 }
 
 // bit N (matching NetGameType N) = this level matches that game type's level
@@ -646,8 +597,8 @@ static bool is_level_valid_for_vote_gametype(const std::string& level_name, rf::
 static uint32_t build_level_valid_gametype_mask(const std::string& level_name)
 {
     uint32_t mask = 0;
-    for (int i = 0; i <= static_cast<int>(rf::NG_TYPE_SAL); ++i) {
-        if (does_level_match_gametype_prefix(level_name, static_cast<rf::NetGameType>(i))) {
+    for (int i = 0; i < static_cast<int>(rf::NG_TYPE_UNK); ++i) {
+        if (multi_level_name_matches_game_type(level_name, static_cast<rf::NetGameType>(i))) {
             mask |= (1u << i);
         }
     }
@@ -779,19 +730,46 @@ static std::string build_rules_title_suffix(std::optional<rf::NetGameType> gamet
     return suffix;
 }
 
+// The game type a vote title names: an explicit one always, an inherited one only when
+// it differs from what is running.
+static std::optional<rf::NetGameType> title_gametype(std::optional<rf::NetGameType> voted,
+                                                     rf::NetGameType effective)
+{
+    if (voted) {
+        return voted;
+    }
+    if (effective != rf::netgame.type) {
+        return effective;
+    }
+    return std::nullopt;
+}
+
+// An explicit voted set replaces the baseline; a chat vote names none and inherits.
+static std::vector<MutatorDeclaration> effective_vote_mutators(
+    const std::vector<MutatorDeclaration>& voted, bool voted_set_is_explicit)
+{
+    if (voted_set_is_explicit) {
+        return voted;
+    }
+    return g_alpine_server_config_active_rules.mutators.declarations;
+}
+
 struct VoteMatch : public Vote
 {
     int m_team_size;
     std::string m_level_name;
     std::optional<rf::NetGameType> m_gametype;
     std::vector<MutatorDeclaration> m_mutators;
-    std::optional<ManualRulesOverride> m_manual_rules_override;
+    bool m_mutators_explicit;
+    ManualRulesOverride m_manual_rules_override;
     std::string m_mutator_labels;
+    // Resolved in validate(); see title_gametype.
+    std::optional<rf::NetGameType> m_title_gametype;
 
     VoteMatch(int team_size, std::string level_name, std::optional<rf::NetGameType> gametype,
-              std::vector<MutatorDeclaration> mutators)
+              std::vector<MutatorDeclaration> mutators, bool mutators_explicit)
         : m_team_size(team_size), m_level_name(std::move(level_name)), m_gametype(gametype),
-          m_mutators(std::move(mutators))
+          m_mutators(std::move(mutators)), m_mutators_explicit(mutators_explicit)
     {}
 
     VoteType get_type() const override
@@ -819,15 +797,8 @@ struct VoteMatch : public Vote
             m_level_name = std::move(normalized_name);
         }
 
-        // A match on the current level with no rules override keeps the level
-        // (and therefore its active rules) exactly as they are; anything else
-        // re-resolves from the level's natural rules. Level names are compared
-        // case-insensitively: they come from a client packet, a config file and the
-        // engine, none of which agree on case.
-        const bool builds_override = !m_mutators.empty() || m_gametype.has_value();
-        const bool using_current_level = string_iequals(m_level_name, rf::level.filename.c_str());
-        const rf::NetGameType effective_game_type = resolve_effective_vote_game_type(
-            m_level_name, m_gametype, builds_override, using_current_level);
+        const rf::NetGameType effective_game_type =
+            m_gametype.value_or(resolve_level_default_game_type(m_level_name));
 
         if (!is_level_allowed_for_vote(m_level_name, source, effective_game_type)) {
             return false;
@@ -845,8 +816,14 @@ struct VoteMatch : public Vote
             return false;
         }
 
-        m_manual_rules_override = load_vote_rules_override(m_level_name, m_mutators, m_gametype);
-        m_mutator_labels = mutators_join_labels(m_mutators);
+        const std::vector<MutatorDeclaration> effective_mutators =
+            effective_vote_mutators(m_mutators, m_mutators_explicit);
+        // Always derived, like a level vote: never the rotation slot's own rules.
+        m_manual_rules_override =
+            load_vote_rules_override(m_level_name, effective_mutators, effective_game_type);
+        m_manual_rules_override.explicit_session = m_gametype.has_value() || m_mutators_explicit;
+        m_mutator_labels = mutators_join_labels(effective_mutators, effective_game_type);
+        m_title_gametype = title_gametype(m_gametype, effective_game_type);
 
         // Deliberately does NOT touch g_match_info: validation passing only means
         // the vote may be PUT, not that it wins. Writing team_size /
@@ -858,7 +835,7 @@ struct VoteMatch : public Vote
     [[nodiscard]] std::string get_title() const override
     {
         return std::format("START {}v{} MATCH on {}{}", m_team_size, m_team_size, m_level_name,
-                           build_rules_title_suffix(m_gametype, m_mutator_labels));
+                           build_rules_title_suffix(m_title_gametype, m_mutator_labels));
     }
 
     // How the accepted match will actually start. Computed by both the outcome text
@@ -876,16 +853,8 @@ struct VoteMatch : public Vote
         // on_accepted() publishes the match state, and it is the vote's own level
         // that matters anyway.
         plan.level_is_current = string_iequals(m_level_name, rf::level.filename.c_str());
-
-        bool game_type_matches_current = true;
-        if (plan.level_is_current) {
-            const rf::NetGameType desired_game_type =
-                m_manual_rules_override ? m_manual_rules_override->rules.game_type
-                                        : g_alpine_server_config_active_rules.game_type;
-            game_type_matches_current = (desired_game_type == rf::netgame.type);
-        }
-
-        plan.using_current_level = plan.level_is_current && game_type_matches_current;
+        plan.using_current_level =
+            plan.level_is_current && m_manual_rules_override.rules.game_type == rf::netgame.type;
         return plan;
     }
 
@@ -918,26 +887,20 @@ struct VoteMatch : public Vote
         g_match_info.pre_match_queued = true;
 
         if (using_current_level) {
-            if (m_manual_rules_override) {
-                set_manual_rules_override(std::move(*m_manual_rules_override));
-                apply_rules_for_current_level();
-                // Clients need the new mutator flags now, not at the match-start restart.
-                af_send_server_info_packet_to_all();
-                m_manual_rules_override.reset();
-            }
+            set_manual_rules_override(std::move(m_manual_rules_override));
+            apply_rules_for_current_level();
+            // Clients need the new mutator flags now, not at the match-start restart.
+            af_send_server_info_packet_to_all();
             start_pre_match();
         }
         else if (!m_level_name.empty()) {
-            if (!m_manual_rules_override)
-                clear_manual_rules_override();
+            clear_manual_rules_override();
             if (m_gametype)
                 set_upcoming_game_type(*m_gametype, UpcomingGameTypeSelection::ExplicitRequest);
             afstats::note_game_end_type(afstats::GameEndType::map_change_vote);
             multi_change_level_alpine(m_level_name.c_str());
-            if (m_manual_rules_override) {
-                set_manual_rules_override(std::move(*m_manual_rules_override));
-                m_manual_rules_override.reset();
-            }
+            // AFTER the level switch, which drops the override for a rotation level.
+            set_manual_rules_override(std::move(m_manual_rules_override));
         }
     }
 
@@ -1137,12 +1100,16 @@ struct VoteLevel : public Vote
     std::string m_level_name;
     std::optional<rf::NetGameType> m_gametype;
     std::vector<MutatorDeclaration> m_mutators;
-    std::optional<ManualRulesOverride> m_manual_rules_override;
+    bool m_mutators_explicit;
+    ManualRulesOverride m_manual_rules_override;
     std::string m_mutator_labels;
+    // Resolved in validate(); see title_gametype.
+    std::optional<rf::NetGameType> m_title_gametype;
 
     VoteLevel(std::string level_name, std::optional<rf::NetGameType> gametype,
-              std::vector<MutatorDeclaration> mutators)
-        : m_level_name(std::move(level_name)), m_gametype(gametype), m_mutators(std::move(mutators))
+              std::vector<MutatorDeclaration> mutators, bool mutators_explicit)
+        : m_level_name(std::move(level_name)), m_gametype(gametype), m_mutators(std::move(mutators)),
+          m_mutators_explicit(mutators_explicit)
     {}
 
     VoteType get_type() const override
@@ -1162,25 +1129,27 @@ struct VoteLevel : public Vote
 
         m_level_name = std::move(level_name);
 
-        // A level vote always reloads the level, so it never keeps the currently
-        // active rules — the target always re-resolves from rotation/base.
-        const bool builds_override = !m_mutators.empty() || m_gametype.has_value();
-        const rf::NetGameType effective_game_type = resolve_effective_vote_game_type(
-            m_level_name, m_gametype, builds_override, /*keeps_current_level*/ false);
+        const rf::NetGameType effective_game_type =
+            m_gametype.value_or(resolve_level_default_game_type(m_level_name));
 
         if (!is_level_allowed_for_vote(m_level_name, source, effective_game_type)) {
             return false;
         }
 
-        m_manual_rules_override = load_vote_rules_override(m_level_name, m_mutators, m_gametype);
-        m_mutator_labels = mutators_join_labels(m_mutators);
+        const std::vector<MutatorDeclaration> effective_mutators =
+            effective_vote_mutators(m_mutators, m_mutators_explicit);
+        m_manual_rules_override =
+            load_vote_rules_override(m_level_name, effective_mutators, effective_game_type);
+        m_manual_rules_override.explicit_session = m_gametype.has_value() || m_mutators_explicit;
+        m_mutator_labels = mutators_join_labels(effective_mutators, effective_game_type);
+        m_title_gametype = title_gametype(m_gametype, effective_game_type);
         return true;
     }
 
     [[nodiscard]] std::string get_title() const override
     {
         return std::format("LOAD LEVEL '{}'{}", m_level_name,
-                           build_rules_title_suffix(m_gametype, m_mutator_labels));
+                           build_rules_title_suffix(m_title_gametype, m_mutator_labels));
     }
 
     [[nodiscard]] std::string get_outcome_text(bool accepted) const override
@@ -1189,7 +1158,7 @@ struct VoteLevel : public Vote
             return Vote::get_outcome_text(false);
         }
         return std::format("Vote passed: changing level to {}{}", m_level_name,
-                           build_rules_title_suffix(m_gametype, m_mutator_labels));
+                           build_rules_title_suffix(m_title_gametype, m_mutator_labels));
     }
 
     void on_accepted() override
@@ -1203,10 +1172,8 @@ struct VoteLevel : public Vote
         afstats::note_game_end_type(afstats::GameEndType::map_change_vote);
         multi_change_level_alpine(m_level_name.c_str());
 
-        if (m_manual_rules_override) {
-            set_manual_rules_override(std::move(*m_manual_rules_override));
-            m_manual_rules_override.reset();
-        }
+        // AFTER the level switch, which drops the override for a rotation level.
+        set_manual_rules_override(std::move(m_manual_rules_override));
     }
 
     [[nodiscard]] std::string get_detail() const override { return m_level_name; }
@@ -1235,11 +1202,8 @@ struct VoteRotation : public Vote
 
     bool validate([[maybe_unused]] rf::Player* source) override
     {
-        // Preserve means "keep the overrides a vote set for this session", not
-        // "propagate whatever is running": with no session override in play it is
-        // a no-op, so a default-checked Next vote cannot stamp this level's
-        // configured game type onto the operator's next rotation entry.
-        if (!m_preserve || !g_manual_rules_override) {
+        // Preserve means "keep the rules a vote EXPLICITLY set for this session"
+        if (!m_preserve || !g_manual_rules_override || !g_manual_rules_override->explicit_session) {
             return true;
         }
 
@@ -1247,7 +1211,7 @@ struct VoteRotation : public Vote
         m_carried_mutators = active.mutators.declarations;
         // Only carry a game type that actually deviates from what this level runs
         // on its own; otherwise the target level's own configured type must win.
-        if (active.game_type != vote_natural_rules_for_level(rf::level.filename.c_str()).game_type) {
+        if (active.game_type != resolve_level_default_game_type(rf::level.filename.c_str())) {
             m_carried_gametype = active.game_type;
         }
         m_carried_labels = mutators_join_labels(m_carried_mutators);
@@ -1567,6 +1531,8 @@ VoteMgr g_vote_mgr;
 // ============================================================================
 
 static std::vector<uint8_t> g_vote_options_blob;
+// Scratch the blob is rebuilt into, so the cached copy survives the comparison.
+static std::vector<uint8_t> g_vote_options_blob_scratch;
 // Wide enough that it can never wrap. A u8 wrapped every 256 rebuilds (a rotation
 // shuffle bumps it once per cycle), and a client holding a stale blob at a
 // recurring generation would then never refresh.
@@ -1794,7 +1760,14 @@ static uint32_t build_enabled_vote_mask()
     uint32_t mask = 0;
     if (cfg.vote_kick.enabled) mask |= bit(AfVoteType::Kick);
     if (cfg.vote_level.enabled) mask |= bit(AfVoteType::Level);
-    if (cfg.vote_match.enabled) mask |= bit(AfVoteType::Match) | bit(AfVoteType::CancelMatch);
+    // VoteMatch::validate refuses every match on a server whose base game type is
+    // not a team type, so Match is not advertised there rather than being offered
+    // and always rejected. CancelMatch stays advertised: a live match can outlast a
+    // config change to a non-team base type, and the vote panel is its only caller.
+    if (cfg.vote_match.enabled) {
+        if (multi_game_type_is_team_type(cfg.base_rules.game_type)) mask |= bit(AfVoteType::Match);
+        mask |= bit(AfVoteType::CancelMatch);
+    }
     if (cfg.vote_extend.enabled) mask |= bit(AfVoteType::Extend);
     if (cfg.vote_restart.enabled) mask |= bit(AfVoteType::Restart);
     if (cfg.vote_next.enabled) mask |= bit(AfVoteType::Next);
@@ -1820,7 +1793,7 @@ static void build_vote_options_blob(std::vector<uint8_t>& blob)
     // Game types. Length-prefixed per entry (u16, not u8: display_name alone can be
     // 255 bytes plus the fixed fields), so per-gametype data can be appended inside
     // the entry later without desyncing an older client.
-    const int gametype_count = static_cast<int>(rf::NG_TYPE_SAL) + 1;
+    const int gametype_count = static_cast<int>(rf::NG_TYPE_UNK);
     blob_u8(blob, static_cast<uint8_t>(gametype_count));
     for (int i = 0; i < gametype_count; ++i) {
         const auto game_type = static_cast<rf::NetGameType>(i);
@@ -1901,20 +1874,17 @@ static void build_vote_options_blob(std::vector<uint8_t>& blob)
         const std::string& level = levels[i];
         blob_sized_u16(blob, [&] {
             blob_str(blob, level);
-            blob_u8(blob, static_cast<uint8_t>(vote_natural_rules_for_level(level).game_type));
+            // Exactly what resolve_level_default_game_type answers.
+            blob_u8(blob, static_cast<uint8_t>(resolve_level_default_game_type(level)));
             blob_u32(blob, build_level_valid_gametype_mask(level));
             // Derived from the SAME predicate the call-time gate uses, so the blob can
             // never advertise a level the server would refuse.
             blob_u8(blob, is_level_in_vote_allow_list(level) ? AF_VOTE_LEVEL_FLAG_ALLOWED : 0);
 
-            // Which mutator set the panel pre-selects for this level. A rotation
-            // entry's rules start life as a copy of the base rules, so an entry
-            // that declares nothing of its own compares equal to the base set and
-            // simply inherits it; an entry whose set differs -- including one that
-            // deliberately clears it -- carries its own.
+            // Which mutator set the panel pre-selects for this level.
             const std::vector<MutatorDeclaration>* level_decls = nullptr;
             for (const auto& entry : g_alpine_server_config.levels) {
-                // Same lookup as vote_natural_rules_for_level: first match wins.
+                // Same lookup as resolve_level_default_game_type: first match wins.
                 if (string_iequals(entry.level_filename, level)) {
                     level_decls = &entry.rule_overrides.mutators.declarations;
                     break;
@@ -1931,10 +1901,19 @@ static void build_vote_options_blob(std::vector<uint8_t>& blob)
         });
     }
 
-    // The base mutator set, as a trailing section: every level that inherits
-    // (kind 0 above) pre-selects this, and so does a manually named level outside
-    // the rotation.
-    blob_declaration_set(blob, g_alpine_server_config.base_rules.mutators.declarations);
+    // The base mutator set, as a trailing section.
+    blob_sized_u16(blob, [&] {
+        blob_declaration_set(blob, g_alpine_server_config.base_rules.mutators.declarations);
+    });
+
+    // The base rules' game type: the fallback for a name nothing else claims.
+    blob_u8(blob, static_cast<uint8_t>(g_alpine_server_config.base_rules.game_type));
+}
+
+void server_vote_build_active_mutators_blob(std::vector<uint8_t>& blob)
+{
+    blob.clear();
+    blob_declaration_set(blob, g_alpine_server_config_active_rules.mutators.declarations);
 }
 
 void server_vote_invalidate_options_blob()
@@ -1942,14 +1921,27 @@ void server_vote_invalidate_options_blob()
     g_vote_options_blob_valid = false;
 }
 
+bool server_vote_refresh_options_blob()
+{
+    const uint32_t before = g_vote_options_generation;
+    uint32_t after = 0;
+    server_vote_get_options_blob(after);
+    return after != before;
+}
+
 const std::vector<uint8_t>& server_vote_get_options_blob(uint32_t& generation)
 {
     if (!g_vote_options_blob_valid) {
-        build_vote_options_blob(g_vote_options_blob);
-        ++g_vote_options_generation; // starts at 1, so 0 means "nothing sent yet"
+        // Content-addressed: every level load invalidates the cache but almost all
+        // rebuild the same bytes, and a generation bump re-streams to every client.
+        build_vote_options_blob(g_vote_options_blob_scratch);
+        if (g_vote_options_blob_scratch != g_vote_options_blob) {
+            g_vote_options_blob.swap(g_vote_options_blob_scratch);
+            ++g_vote_options_generation; // starts at 1, so 0 means "nothing sent yet"
+            xlog::debug("vote options: rebuilt blob ({} bytes, generation {})",
+                        g_vote_options_blob.size(), g_vote_options_generation);
+        }
         g_vote_options_blob_valid = true;
-        xlog::debug("vote options: rebuilt blob ({} bytes, generation {})",
-                    g_vote_options_blob.size(), g_vote_options_generation);
     }
     generation = g_vote_options_generation;
     return g_vote_options_blob;
@@ -2124,10 +2116,10 @@ static bool resolve_vote_gametype(uint8_t wire_value, rf::Player* sender, std::o
     return true;
 }
 
-static bool resolve_vote_mutators(const std::vector<VoteMutatorInput>& input, rf::Player* sender,
-                                  std::vector<MutatorDeclaration>& out)
+static bool resolve_vote_mutators(const std::vector<VoteMutatorInput>& input, rf::NetGameType game_type,
+                                  rf::Player* sender, std::vector<MutatorDeclaration>& out)
 {
-    if (auto error = mutators_build_declarations_from_vote(input, out)) {
+    if (auto error = mutators_build_declarations_from_vote(input, game_type, out)) {
         send_vote_reject_msg(std::format("Cannot start vote: {}", *error), sender);
         return false;
     }
@@ -2160,19 +2152,23 @@ void handle_vote_call_packet(rf::Player* sender, AfVoteCallParams&& params)
             break;
         }
         case AfVoteType::Level: {
+            if (params.level.empty()) {
+                send_vote_reject_msg("Cannot start vote: no level was specified.", sender);
+                return;
+            }
             std::optional<rf::NetGameType> gametype;
             if (!resolve_vote_gametype(params.gametype, sender, gametype)) {
                 return;
             }
             std::vector<MutatorDeclaration> mutators;
-            if (!resolve_vote_mutators(params.mutators, sender, mutators)) {
-                return;
-            }
-            if (params.level.empty()) {
-                send_vote_reject_msg("Cannot start vote: no level was specified.", sender);
+            // Same resolution validate() applies, so the type checked is the one that
+            // would actually run.
+            if (!resolve_vote_mutators(params.mutators,
+                    gametype.value_or(resolve_level_default_game_type(params.level)), sender, mutators)) {
                 return;
             }
-            g_vote_mgr.StartVote<VoteLevel>(sender, std::move(params.level), gametype, std::move(mutators));
+            g_vote_mgr.StartVote<VoteLevel>(sender, std::move(params.level), gametype, std::move(mutators),
+                                            params.mutators_explicit);
             break;
         }
         case AfVoteType::Match: {
@@ -2180,12 +2176,17 @@ void handle_vote_call_packet(rf::Player* sender, AfVoteCallParams&& params)
             if (!resolve_vote_gametype(params.gametype, sender, gametype)) {
                 return;
             }
+            // An empty level means the current one, exactly as validate() reads it.
+            const std::string match_level =
+                params.level.empty() ? std::string{rf::level.filename.c_str()} : params.level;
             std::vector<MutatorDeclaration> mutators;
-            if (!resolve_vote_mutators(params.mutators, sender, mutators)) {
+            if (!resolve_vote_mutators(params.mutators,
+                    gametype.value_or(resolve_level_default_game_type(match_level)), sender, mutators)) {
                 return;
             }
             g_vote_mgr.StartVote<VoteMatch>(sender, static_cast<int>(params.team_size),
-                                            std::move(params.level), gametype, std::move(mutators));
+                                            std::move(params.level), gametype, std::move(mutators),
+                                            params.mutators_explicit);
             break;
         }
         case AfVoteType::Extend:
diff --git a/game_patch/os/os.cpp b/game_patch/os/os.cpp
index f0215f8f6..3764ca8c8 100644
--- a/game_patch/os/os.cpp
+++ b/game_patch/os/os.cpp
@@ -249,6 +249,9 @@ bool headless_bot_requested_from_raw_cmdline()
 
 bool awpgen_requested_from_raw_cmdline()
 {
+    if (rf::is_dedicated_server) {
+        return false;
+    }
     return raw_command_line_has_switch(L"-awpgen");
 }