diff --git a/example_community_patch_settings_en.toml b/example_community_patch_settings_en.toml
index 93faa6b7a..943c169b2 100644
--- a/example_community_patch_settings_en.toml
+++ b/example_community_patch_settings_en.toml
@@ -471,6 +471,10 @@ quit = "F10"
 # F9
 restart = "F9"
 
+# Re-read this settings file now. It is also re-read by itself about a second after it is saved; changes to
+# [patches] still need a restart.
+reload_settings = "CTRL-SHIFT-F6"
+
 # CTRL-ALT-MINUS
 set_hotkeys_disabled = "CTRL-ALT-MINUS"
 
diff --git a/libs/il2cpp/include/il2cpp/hook.h b/libs/il2cpp/include/il2cpp/hook.h
new file mode 100644
index 000000000..a264d2bae
--- /dev/null
+++ b/libs/il2cpp/include/il2cpp/hook.h
@@ -0,0 +1,93 @@
+#pragma once
+
+// Detours on managed methods and runtime functions. A missing method is already reported by its lookup; these
+// report a detour SPUD could not install, which SPUD_STATIC_DETOUR alone would drop without a word. Like it, they
+// install permanently: nothing removes them, so their stubs skip SPUD's per-call entry counting.
+//
+// Hooks take the original as their first parameter:
+//   void ScreenManager_Update_Hook(auto original, ScreenManager* _this) { ...; original(_this); }
+//   IL2CPP_HOOK(ScreenManager::Class::Method("Update"), ScreenManager_Update_Hook);
+// Each expansion installs one detour on its first call, so expand it once per target: a second call from the same
+// place returns the first call's trampoline and installs nothing.
+
+#include "il2cpp.h"
+
+#include <spud/detour.h>
+#include <spud/diagnostics.h>
+
+#include <string>
+#include <string_view>
+
+namespace il2cpp::detail
+{
+void ReportDetourFailure(std::string_view target, const char* error);
+
+constexpr const char* DetourErrorName(spud::detour_error error)
+{
+  using E = spud::detour_error;
+  switch (error) {
+    case E::kOk:
+      return "ok";
+    case E::kUnsupportedArch:
+      return "unsupported architecture";
+    case E::kDecodeFailed:
+      return "prologue could not be decoded";
+    case E::kInsufficientBytes:
+      return "function too short for a detour";
+    case E::kProtectionFailed:
+      return "page protection could not be changed";
+    case E::kSuspensionUnavailable:
+      return "other threads could not be suspended";
+    case E::kTargetChanged:
+      return "target changed while installing";
+    case E::kBusy:
+      return "detour busy";
+    case E::kChainFull:
+      return "too many detours on one function";
+    case E::kControlFlowEnforced:
+      return "control-flow protection";
+    case E::kNotFound:
+      return "not found";
+    case E::kUnwindFailed:
+      return "unwind metadata could not be registered";
+    case E::kRollbackFailed:
+      return "rollback failed";
+  }
+  return "unknown error";
+}
+
+inline bool Installed(spud::detour_error error, std::string_view target)
+{
+  if (error == spud::detour_error::kOk)
+    return true;
+  const auto  detail = spud::last_failure_detail();
+  std::string message = DetourErrorName(error);
+  if (detail.reason)
+    message += std::string(": ") + detail.reason;
+  ReportDetourFailure(target, message.c_str());
+  return false;
+}
+
+inline bool Installed(spud::detour_error error, const Method& target)
+{ return error == spud::detour_error::kOk || Installed(error, target.Name()); }
+} // namespace il2cpp::detail
+
+// Detours `address` with `hook`; `name` (a string or an il2cpp::Method) labels a failure. Evaluates to the
+// trampoline that calls the original, or null when nothing was installed.
+#define IL2CPP_DETOUR(address, hook, name)                                                                             \
+  ([&](void* target_) {                                                                                                \
+    using Trampoline_                    = decltype(SPUD_AUTO_HOOK(target_, hook).trampoline());                       \
+    static const Trampoline_ trampoline_ = [&]() -> Trampoline_ {                                                      \
+      if (!target_)                                                                                                    \
+        return nullptr;                                                                                                \
+      auto detour_ = SPUD_AUTO_HOOK(target_, hook);                                                                    \
+      if (!::il2cpp::detail::Installed(detour_.try_install_permanent(), name))                                         \
+        return nullptr;                                                                                                \
+      return detour_.trampoline();                                                                                     \
+    }();                                                                                                               \
+    return trampoline_;                                                                                                \
+  }(reinterpret_cast<void*>(address)))
+
+// Detours the native code of a managed method from Class::Method. A missing method installs nothing.
+#define IL2CPP_HOOK(method, hook)                                                                                      \
+  ([&](const ::il2cpp::Method& method_) { return IL2CPP_DETOUR(method_.Pointer(), hook, method_); }(method))
diff --git a/libs/il2cpp/include/il2cpp/il2cpp.h b/libs/il2cpp/include/il2cpp/il2cpp.h
index 13a37c4c2..a2fc9517c 100644
--- a/libs/il2cpp/include/il2cpp/il2cpp.h
+++ b/libs/il2cpp/include/il2cpp/il2cpp.h
@@ -14,6 +14,7 @@
 #include <initializer_list>
 #include <optional>
 #include <span>
+#include <string>
 #include <string_view>
 #include <type_traits>
 #include <unordered_map>
@@ -25,6 +26,10 @@ namespace il2cpp
 // Missing classes and members, and signatures that no longer match the binding, are reported
 // once per lookup. Without a handler, reports go to stderr.
 void SetErrorHandler(void (*handler)(std::string_view message));
+// Sends a message through the same handler; for libraries built on this one.
+void Report(std::string_view message);
+// "Namespace.Outer/Inner", for diagnostics.
+std::string ClassName(Il2CppClass* klass);
 
 // Compile-time member name, used as a template argument: Call<"Show">().
 template <size_t N> struct Name {
@@ -51,6 +56,8 @@ class Method
   // Generated code takes `this` first (for instance methods) and a trailing const MethodInfo*.
   void* Pointer() const
   { return info_ ? reinterpret_cast<void*>(info_->methodPointer) : nullptr; }
+  // "Namespace.Class.Method", for diagnostics.
+  std::string Name() const;
 
 private:
   const MethodInfo* info_ = nullptr;
@@ -76,6 +83,9 @@ namespace detail
 
   Il2CppClass* StringClass();
   Il2CppClass* TypeClass();
+  // System.Int32 and friends from corlib, by element type; null for anything else.
+  Il2CppClass* PrimitiveClass(Il2CppTypeEnum type);
+  void         ReportFault(const char* what);
 
   template <typename T>
   concept Bound = requires { T::Class::Raw(); };
@@ -119,11 +129,11 @@ namespace detail
   }
 
   template <typename T> struct Unref {
-    using Type                  = T;
+    using Type                   = T;
     static constexpr bool kByRef = false;
   };
   template <typename T> struct Unref<std::reference_wrapper<T>> {
-    using Type                  = T;
+    using Type                   = T;
     static constexpr bool kByRef = true;
   };
 
@@ -150,13 +160,14 @@ namespace detail
   }
 
   template <typename... A> inline constexpr std::array<Slot, sizeof...(A)> kParams{SlotOf<A>()...};
-  template <typename R, typename... A> constexpr Signature SignatureOf()
+  template <typename R, typename... A> constexpr Signature                 SignatureOf()
   { return {SlotOf<R>(), kParams<A...>}; }
 
-  Il2CppClass*      FindClass(std::string_view assembly, std::string_view namespaze, std::string_view name);
-  Method            FindMethod(Il2CppClass* klass, std::string_view name, int count);
-  Method            FindMethod(Il2CppClass* klass, std::string_view name, std::initializer_list<std::string_view> params);
-  const MethodInfo* ResolveMethod(Il2CppClass* klass, std::string_view name, const Signature& signature, bool is_static);
+  Il2CppClass* FindClass(std::string_view assembly, std::string_view namespaze, std::string_view name);
+  Method       FindMethod(Il2CppClass* klass, std::string_view name, int count);
+  Method       FindMethod(Il2CppClass* klass, std::string_view name, std::initializer_list<std::string_view> params);
+  const MethodInfo* ResolveMethod(Il2CppClass* klass, std::string_view name, const Signature& signature,
+                                  bool is_static);
   const MethodInfo* ResolveProperty(Il2CppClass* klass, std::string_view name, const Slot& value, bool setter,
                                     bool is_static);
   FieldInfo*        ResolveField(Il2CppClass* klass, std::string_view name, const Slot& value, bool is_static);
@@ -184,9 +195,9 @@ namespace detail
     }
   }
 
-  template <typename T> using Native = std::conditional_t<
-      Unref<T>::kByRef, typename Unref<T>::Type*,
-      std::conditional_t<std::is_same_v<T, std::nullptr_t>, void*, T>>;
+  template <typename T>
+  using Native = std::conditional_t<Unref<T>::kByRef, typename Unref<T>::Type*,
+                                    std::conditional_t<std::is_same_v<T, std::nullptr_t>, void*, T>>;
   template <typename T> Native<T> ToNative(T& value)
   {
     if constexpr (Unref<T>::kByRef)
@@ -357,11 +368,13 @@ template <Name Assembly, Name Namespace, Name TypeName> struct Class {
     static Il2CppClass* const klass = detail::FindClass(Assembly.View(), Namespace.View(), TypeName.View());
     return klass;
   }
+  // The System.Type for this class. Cached: the runtime keeps type objects in a rooted, append-only cache, and
+  // looking one up takes its reflection lock.
   static Il2CppReflectionType* TypeObject()
   {
-    auto* klass = Raw();
-    return klass ? reinterpret_cast<Il2CppReflectionType*>(il2cpp_type_get_object(il2cpp_class_get_type(klass)))
-                 : nullptr;
+    static Il2CppReflectionType* const type =
+        Raw() ? reinterpret_cast<Il2CppReflectionType*>(il2cpp_type_get_object(il2cpp_class_get_type(Raw()))) : nullptr;
+    return type;
   }
 
   // Lookups for detours. A count of -1 accepts any arity; parameter names are "Namespace.Type".
@@ -370,6 +383,21 @@ template <Name Assembly, Name Namespace, Name TypeName> struct Class {
   static il2cpp::Method Method(std::string_view name, std::initializer_list<std::string_view> params)
   { return detail::FindMethod(Raw(), name, params); }
 
+  // An instance method with its complete C++ signature, for hooks that must reject client ABI drift.
+  template <typename F> static il2cpp::Method Method(std::string_view name)
+  {
+    const auto* method = detail::MethodCall<F>::Resolve(Raw(), name, false);
+    if (method && (method->has_full_generic_sharing_signature || (method->flags & METHOD_ATTRIBUTE_ABSTRACT))) {
+      Report("[IL2CPP] cannot hook shared or abstract method " + ClassName(Raw()) + "." + std::string(name));
+      return {};
+    }
+    return il2cpp::Method(method);
+  }
+
+  // Checks an instance field's schema without reading an object, for hooks that write several related fields.
+  template <Name N, typename T> static bool HasField()
+  { return detail::ResolveField(Raw(), N.View(), detail::SlotOf<T>(), false) != nullptr; }
+
   template <Name N, typename F = void, typename... A> static auto Call(A&&... args)
   {
     using Sig                 = detail::CallOf<F, std::decay_t<A>...>;
@@ -401,6 +429,10 @@ template <Name Assembly, Name Namespace, Name TypeName> struct Class {
 // Base for reference-type bindings. A binding pointer is the managed object itself; bindings add
 // no data members. Receivers must not be null. Missing members return a value-initialized result.
 struct Object : Il2CppObject {
+  // Checks a method on the receiver's runtime class, including inflated collection types.
+  template <typename F, typename Self> il2cpp::Method Method(this Self& self, std::string_view name)
+  { return il2cpp::Method(detail::MethodCall<F>::Resolve(self.klass, name, false)); }
+
   template <Name N, typename T, typename Self> T Get(this Self& self)
   {
     auto* getter = detail::Lookup<Self>(self, [](Il2CppClass* klass) {
@@ -417,16 +449,14 @@ struct Object : Il2CppObject {
   }
   template <Name N, typename T, typename Self> T Field(this Self& self)
   {
-    auto* field = detail::Lookup<Self>(self, [](Il2CppClass* klass) {
-      return detail::ResolveField(klass, N.View(), detail::SlotOf<T>(), false);
-    });
+    auto* field = detail::Lookup<Self>(
+        self, [](Il2CppClass* klass) { return detail::ResolveField(klass, N.View(), detail::SlotOf<T>(), false); });
     return detail::ReadField<T>(field, &self);
   }
   template <Name N, typename Self, typename T> void SetField(this Self& self, T value)
   {
-    auto* field = detail::Lookup<Self>(self, [](Il2CppClass* klass) {
-      return detail::ResolveField(klass, N.View(), detail::SlotOf<T>(), false);
-    });
+    auto* field = detail::Lookup<Self>(
+        self, [](Il2CppClass* klass) { return detail::ResolveField(klass, N.View(), detail::SlotOf<T>(), false); });
     detail::WriteField(field, &self, value);
   }
   // Call<"Name", R>(args) selects the overload by the C++ argument types; std::ref marks ref/out
@@ -468,6 +498,98 @@ template <typename T, typename... A> T* New(A... args)
   return object;
 }
 
+// Allocate T without running any constructor, for classes whose parameterless constructor has no generated code.
+// Every field the game will read has to be set by the caller. Null when the class is missing.
+template <typename T> T* Allocate()
+{
+  auto* klass = T::Class::Raw();
+  return klass ? static_cast<T*>(il2cpp_object_new(klass)) : nullptr;
+}
+
+// System.Object, the element class of object[].
+Il2CppClass* ObjectClass();
+
+// The corlib class of a primitive C++ type: System.Byte for uint8_t, System.Int64 for int64_t.
+template <typename T> Il2CppClass* PrimitiveClass()
+{
+  static_assert(std::is_arithmetic_v<T>, "only primitives have a corlib class here");
+  return detail::PrimitiveClass(detail::Primitive<T>());
+}
+
+// A boxed primitive, for object parameters and object[] arguments.
+template <typename T> Il2CppObject* Box(T value)
+{
+  auto* klass = PrimitiveClass<T>();
+  return klass ? il2cpp_value_box(klass, &value) : nullptr;
+}
+
+// A new managed string. Like any managed object it lives while something managed or the native stack holds it.
+inline Il2CppString* NewString(std::string_view utf8)
+{ return il2cpp_string_new_len(utf8.data(), static_cast<uint32_t>(utf8.size())); }
+
+// The string as UTF-8; empty for null.
+std::string ToUtf8(const Il2CppString* str);
+
+// Compares a managed string with ASCII text without converting it, for checks on hot paths.
+inline bool Equals(const Il2CppString* str, std::string_view ascii)
+{
+  if (!str || static_cast<size_t>(str->length) != ascii.size())
+    return false;
+  for (size_t i = 0; i < ascii.size(); ++i)
+    if (str->chars[i] != static_cast<Il2CppChar>(ascii[i]))
+      return false;
+  return true;
+}
+
+// The text of any object: a string as itself, anything else through its ToString override.
+inline Il2CppString* ToString(Object* object)
+{
+  if (!object)
+    return nullptr;
+  if (object->klass == detail::StringClass())
+    return reinterpret_cast<Il2CppString*>(object);
+  return object->Call<"ToString", Il2CppString*>();
+}
+
+// Instance fields of the object's class and its bases, most derived first. For reading game data whose field
+// names drift between builds; bindings should name their fields.
+template <typename Visit> void ForEachInstanceField(Il2CppObject* object, Visit visit)
+{
+  for (auto* klass = object ? object->klass : nullptr; klass; klass = il2cpp_class_get_parent(klass)) {
+    void* iter = nullptr;
+    while (auto* field = il2cpp_class_get_fields(klass, &iter))
+      if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
+        visit(field);
+  }
+}
+
+// A field found by ForEachInstanceField. T must match the field's layout; nothing checks it here.
+template <typename T> T ReadField(Il2CppObject* object, FieldInfo* field)
+{ return detail::ReadField<T>(field, object); }
+
+// Runs the method a delegate is bound to on its target directly, skipping the delegate's invoke stub. Unlike
+// Call, a managed exception is not caught here, so the caller can fall back: catch Il2CppExceptionWrapper.
+template <typename R = void, typename... A> R InvokeBound(Il2CppDelegate* delegate, A... args)
+{ return detail::InvokeNative<R, A...>(delegate->method, delegate->target, args...); }
+
+// Runs `read` and, on Windows, survives an access violation inside it: reading game objects whose layout drifted
+// between client builds should cost a log line, not the game. False, after reporting `what`, when one was caught.
+template <typename Fn> bool Guarded(const char* what, Fn&& read)
+{
+#if _WIN32
+  __try {
+    read();
+  } __except (1 /* EXCEPTION_EXECUTE_HANDLER */) {
+    detail::ReportFault(what);
+    return false;
+  }
+#else
+  (void)what;
+  read();
+#endif
+  return true;
+}
+
 // Managed T[]. Element references are borrowed; use Set to store references with a GC barrier.
 // Set supports references and primitives only.
 template <typename T> struct Array : Il2CppObject {
@@ -509,6 +631,8 @@ template <typename T> struct List : Object {
   { Call<"Add">(value); }
   void RemoveAt(int32_t index)
   { Call<"RemoveAt">(index); }
+  void Clear()
+  { Call<"Clear">(); }
 
   struct Iterator {
     List*   list;
@@ -608,7 +732,43 @@ class GcRoots
   bool                  healthy_ = true;
 };
 
-// Unity engine internal calls, e.g. "UnityEngine.Input::GetKeyInt(UnityEngine.KeyCode)".
-template <typename Signature> Signature* ResolveICall(const char* name)
-{ return reinterpret_cast<Signature*>(il2cpp_resolve_icall(name)); }
+namespace detail
+{
+  void ReportMissingICall(const char* name);
+} // namespace detail
+
+// A Unity engine internal call. One that a Unity upgrade renamed is reported once, when resolved, and then returns
+// the default value instead of calling through null; test it with operator bool to choose another default.
+template <typename Signature> class ICall;
+template <typename R, typename... A> class ICall<R(A...)>
+{
+public:
+  explicit ICall(const char* name)
+      : fn_(reinterpret_cast<R (*)(A...)>(il2cpp_resolve_icall(name)))
+  {
+    if (!fn_)
+      detail::ReportMissingICall(name);
+  }
+
+  explicit operator bool() const
+  { return fn_ != nullptr; }
+
+  R operator()(A... args) const
+  {
+    if constexpr (std::is_void_v<R>) {
+      if (fn_)
+        fn_(args...);
+    } else {
+      return fn_ ? fn_(args...) : R{};
+    }
+  }
+
+private:
+  R (*fn_)(A...);
+};
+
+// Resolves e.g. "UnityEngine.Input::GetKeyInt(UnityEngine.KeyCode)". Keep the result in a static: resolving is a
+// lookup by name.
+template <typename Signature> ICall<Signature> ResolveICall(const char* name)
+{ return ICall<Signature>(name); }
 } // namespace il2cpp
diff --git a/libs/il2cpp/include/il2cpp/method_contract.h b/libs/il2cpp/include/il2cpp/method_contract.h
new file mode 100644
index 000000000..ca9004941
--- /dev/null
+++ b/libs/il2cpp/include/il2cpp/method_contract.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <cstring>
+#include <il2cpp-tabledefs.h>
+#include <il2cpp/api.h>
+#include <initializer_list>
+
+namespace il2cpp::contract
+{
+inline bool Type(const Il2CppType* type, const char* name)
+{
+  if (!type || type->byref)
+    return false;
+  auto*      actual  = il2cpp_type_get_name(type);
+  const bool matches = actual && std::strcmp(actual, name) == 0;
+  il2cpp_free(actual);
+  return matches;
+}
+
+// Resolve the entire managed signature, including static/instance dispatch.
+// A renamed, ambiguous or generic method is not a compatible callback.
+inline const MethodInfo* Resolve(Il2CppClass* cls, const char* name, bool is_static, const char* result,
+                                 std::initializer_list<const char*> parameters)
+{
+  if (!cls)
+    return nullptr;
+  const MethodInfo* found    = nullptr;
+  void*             iterator = nullptr;
+  while (auto* method = il2cpp_class_get_methods(cls, &iterator)) {
+    if (std::strcmp(method->name, name) != 0 || !method->methodPointer || method->is_generic || method->is_inflated
+        || bool(method->flags & METHOD_ATTRIBUTE_STATIC) != is_static || method->parameters_count != parameters.size()
+        || !Type(method->return_type, result))
+      continue;
+    bool     matches = true;
+    unsigned i       = 0;
+    for (auto* parameter : parameters)
+      matches = Type(method->parameters[i++], parameter) && matches;
+    if (!matches)
+      continue;
+    if (found)
+      return nullptr;
+    found = method;
+  }
+  return found;
+}
+
+inline void* Pointer(const MethodInfo* method)
+{ return method ? reinterpret_cast<void*>(method->methodPointer) : nullptr; }
+} // namespace il2cpp::contract
diff --git a/libs/il2cpp/src/il2cpp.cc b/libs/il2cpp/src/il2cpp.cc
index 334a8a519..c859395ef 100644
--- a/libs/il2cpp/src/il2cpp.cc
+++ b/libs/il2cpp/src/il2cpp.cc
@@ -2,6 +2,7 @@
 
 #include <il2cpp/il2cpp.h>
 
+#include <array>
 #include <atomic>
 #include <cstdio>
 #include <mutex>
@@ -10,28 +11,20 @@
 
 namespace il2cpp
 {
+std::string ClassName(Il2CppClass* klass)
+{
+  if (!klass)
+    return "<null>";
+  if (auto* outer = il2cpp_class_get_declaring_type(klass))
+    return ClassName(outer) + "/" + il2cpp_class_get_name(klass);
+  std::string name = il2cpp_class_get_namespace(klass);
+  return name.empty() ? il2cpp_class_get_name(klass) : name + "." + il2cpp_class_get_name(klass);
+}
+
 namespace
 {
   std::atomic<void (*)(std::string_view)> error_handler = nullptr;
 
-  void Report(const std::string& message)
-  {
-    if (auto* handler = error_handler.load())
-      handler(message);
-    else
-      std::fprintf(stderr, "%s\n", message.c_str());
-  }
-
-  std::string ClassName(Il2CppClass* klass)
-  {
-    if (!klass)
-      return "<null>";
-    if (auto* outer = il2cpp_class_get_declaring_type(klass))
-      return ClassName(outer) + "/" + il2cpp_class_get_name(klass);
-    std::string name = il2cpp_class_get_namespace(klass);
-    return name.empty() ? il2cpp_class_get_name(klass) : name + "." + il2cpp_class_get_name(klass);
-  }
-
   std::string TypeName(const Il2CppType* type)
   {
     auto*       raw  = type ? il2cpp_type_get_name(type) : nullptr;
@@ -158,8 +151,61 @@ namespace
 void SetErrorHandler(void (*handler)(std::string_view message))
 { error_handler = handler; }
 
+void Report(std::string_view message)
+{
+  if (auto* handler = error_handler.load())
+    handler(message);
+  else
+    std::fprintf(stderr, "%.*s\n", static_cast<int>(message.size()), message.data());
+}
+
+std::string Method::Name() const
+{ return info_ ? ClassName(info_->klass) + "." + info_->name : "<missing method>"; }
+
+Il2CppClass* ObjectClass()
+{
+  static auto* klass = il2cpp_class_from_name(il2cpp_get_corlib(), "System", "Object");
+  return klass;
+}
+
+std::string ToUtf8(const Il2CppString* str)
+{
+  std::string result;
+  if (!str)
+    return result;
+  result.reserve(static_cast<size_t>(str->length));
+  const auto* chars = str->chars;
+  for (int32_t i = 0; i < str->length; ++i) {
+    uint32_t c = chars[i];
+    // A surrogate pair is one code point; a lone surrogate becomes U+FFFD.
+    if (c >= 0xD800 && c <= 0xDBFF && i + 1 < str->length && chars[i + 1] >= 0xDC00 && chars[i + 1] <= 0xDFFF)
+      c = 0x10000 + ((c - 0xD800) << 10) + (chars[++i] - 0xDC00);
+    else if (c >= 0xD800 && c <= 0xDFFF)
+      c = 0xFFFD;
+    if (c < 0x80) {
+      result += static_cast<char>(c);
+    } else if (c < 0x800) {
+      result += static_cast<char>(0xC0 | (c >> 6));
+      result += static_cast<char>(0x80 | (c & 0x3F));
+    } else if (c < 0x10000) {
+      result += static_cast<char>(0xE0 | (c >> 12));
+      result += static_cast<char>(0x80 | ((c >> 6) & 0x3F));
+      result += static_cast<char>(0x80 | (c & 0x3F));
+    } else {
+      result += static_cast<char>(0xF0 | (c >> 18));
+      result += static_cast<char>(0x80 | ((c >> 12) & 0x3F));
+      result += static_cast<char>(0x80 | ((c >> 6) & 0x3F));
+      result += static_cast<char>(0x80 | (c & 0x3F));
+    }
+  }
+  return result;
+}
+
 namespace detail
 {
+  void ReportMissingICall(const char* name)
+  { Report(std::string("[IL2CPP] missing internal call ") + name); }
+
   Il2CppClass* StringClass()
   {
     static auto* klass = il2cpp_class_from_name(il2cpp_get_corlib(), "System", "String");
@@ -172,6 +218,34 @@ namespace detail
     return klass;
   }
 
+  Il2CppClass* PrimitiveClass(Il2CppTypeEnum type)
+  {
+    static constexpr std::pair<Il2CppTypeEnum, const char*> kNames[] = {
+        {IL2CPP_TYPE_BOOLEAN, "Boolean"}, {IL2CPP_TYPE_CHAR, "Char"}, {IL2CPP_TYPE_I1, "SByte"},
+        {IL2CPP_TYPE_U1, "Byte"},         {IL2CPP_TYPE_I2, "Int16"},  {IL2CPP_TYPE_U2, "UInt16"},
+        {IL2CPP_TYPE_I4, "Int32"},        {IL2CPP_TYPE_U4, "UInt32"}, {IL2CPP_TYPE_I8, "Int64"},
+        {IL2CPP_TYPE_U8, "UInt64"},       {IL2CPP_TYPE_R4, "Single"}, {IL2CPP_TYPE_R8, "Double"},
+    };
+    static std::array<std::atomic<Il2CppClass*>, std::size(kNames)> classes{};
+    for (size_t i = 0; i < std::size(kNames); ++i) {
+      if (kNames[i].first != type)
+        continue;
+      auto* klass = classes[i].load();
+      if (!klass) {
+        klass = il2cpp_class_from_name(il2cpp_get_corlib(), "System", kNames[i].second);
+        classes[i].store(klass);
+      }
+      return klass;
+    }
+    return nullptr;
+  }
+
+  void ReportFault(const char* what)
+  { Report(std::string("[IL2CPP] access violation while reading ") + what); }
+
+  void ReportDetourFailure(std::string_view target, const char* error)
+  { Report("[IL2CPP] could not detour " + std::string(target) + ": " + error); }
+
   Il2CppClass* FindClass(std::string_view assembly, std::string_view namespaze, std::string_view name)
   {
     const std::string assembly_name(assembly), namespace_name(namespaze);
diff --git a/libs/unity/include/unity/core.h b/libs/unity/include/unity/core.h
new file mode 100644
index 000000000..a347b04cc
--- /dev/null
+++ b/libs/unity/include/unity/core.h
@@ -0,0 +1,349 @@
+#pragma once
+
+// UnityEngine's core types for IL2CPP bindings: math structs, objects and their lifetime, scene hierarchy, camera,
+// screen and time, textures and sprites. Nothing here knows about any particular game.
+
+#include <il2cpp/il2cpp.h>
+
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <string_view>
+
+namespace unity
+{
+struct Vector2 {
+  float x, y;
+};
+
+struct Vector3 {
+  float x, y, z;
+};
+
+struct Quaternion {
+  float x, y, z, w;
+};
+
+struct Color {
+  float r, g, b, a;
+};
+
+struct Rect {
+  float x, y, width, height;
+};
+
+// System.TimeSpan: 100 ns ticks.
+struct TimeSpan {
+  int64_t ticks;
+};
+
+using ObjectClass = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Object">;
+
+// Unity's bool(Object): false for null, and for objects whose native side was destroyed even while a GC handle
+// still holds the managed wrapper.
+inline bool Alive(Il2CppObject* object)
+{ return object && ObjectClass::Call<"op_Implicit", bool>(object); }
+
+inline void Destroy(Il2CppObject* object)
+{ ObjectClass::Call<"Destroy">(object); }
+
+// The first loaded object of T. Scans every loaded object; keep it off per-frame paths.
+template <typename T> T* FindObject()
+{
+  auto* type = T::Class::TypeObject();
+  return type ? static_cast<T*>(ObjectClass::Call<"FindObjectOfType", Il2CppObject*>(type)) : nullptr;
+}
+
+// Every active loaded T. Scans every loaded object; keep it off per-frame paths.
+template <typename T> il2cpp::Array<T*>* FindObjectsOfType()
+{
+  auto* type = T::Class::TypeObject();
+  return type ? ObjectClass::Call<"FindObjectsOfType", il2cpp::Array<T*>*>(type) : nullptr;
+}
+
+// Every loaded T, active or not, including prefabs and other assets. Scans every loaded object; keep it off
+// per-frame paths.
+template <typename T> il2cpp::Array<T*>* FindObjectsOfTypeAll()
+{
+  using Resources = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Resources">;
+  auto* type      = T::Class::TypeObject();
+  return type ? Resources::Call<"FindObjectsOfTypeAll", il2cpp::Array<T*>*>(type) : nullptr;
+}
+
+// Behaviour.isActiveAndEnabled through its internal call, for bindings whose managed property may have drifted:
+// without the call everything counts as active.
+inline bool ActiveAndEnabled(il2cpp::Object* behaviour)
+{
+  static const il2cpp::ICall<bool(il2cpp::Object*)> call{"UnityEngine.Behaviour::get_isActiveAndEnabled()"};
+  return !call || call(behaviour);
+}
+
+struct Transform;
+
+struct GameObject : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "GameObject">;
+
+  static GameObject* Find(std::string_view path)
+  { return Class::Call<"Find", GameObject*>(il2cpp::NewString(path)); }
+
+  template <typename T> il2cpp::Array<T*>* GetComponentsInChildren(bool include_inactive)
+  {
+    auto* type = T::Class::TypeObject();
+    return type ? Call<"GetComponentsInChildren", il2cpp::Array<T*>*>(type, include_inactive) : nullptr;
+  }
+
+  // A new, active GameObject with only a Transform, at the scene root.
+  static GameObject* Create(std::string_view name)
+  { return il2cpp::New<GameObject>(il2cpp::NewString(name)); }
+
+  std::string Name()
+  { return il2cpp::ToUtf8(Get<"name", Il2CppString*>()); }
+  bool NameIs(std::string_view ascii)
+  { return il2cpp::Equals(Get<"name", Il2CppString*>(), ascii); }
+  Transform* transform()
+  { return Get<"transform", Transform*>(); }
+  void SetActive(bool active)
+  { Call<"SetActive">(active); }
+
+  // Passing System.Type selects the (Type) overloads over the string and generic ones. A null Type would throw in
+  // managed code, so a missing class yields null instead.
+  template <typename T> T* GetComponent()
+  {
+    auto* type = T::Class::TypeObject();
+    return type ? Call<"GetComponent", T*>(type) : nullptr;
+  }
+  // The first active T on this GameObject or below it, depth first. Searches one hierarchy, where FindObject
+  // searches every loaded object. This Unity only has the (Type, bool includeInactive) overload.
+  template <typename T> T* GetComponentInChildren()
+  {
+    auto* type = T::Class::TypeObject();
+    return type ? Call<"GetComponentInChildren", T*>(type, false) : nullptr;
+  }
+  template <typename T> T* AddComponent()
+  {
+    auto* type = T::Class::TypeObject();
+    return type ? Call<"AddComponent", T*>(type) : nullptr;
+  }
+};
+
+struct Transform : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Transform">;
+
+  int32_t childCount()
+  { return Get<"childCount", int32_t>(); }
+  Transform* GetChild(int32_t index)
+  { return Call<"GetChild", Transform*>(index); }
+  Transform* parent()
+  { return Get<"parent", Transform*>(); }
+  // The topmost transform of this hierarchy; itself when it has no parent.
+  Transform* root()
+  { return Get<"root", Transform*>(); }
+  GameObject* gameObject()
+  { return Get<"gameObject", GameObject*>(); }
+  Vector3 localScale()
+  { return Get<"localScale", Vector3>(); }
+  void SetLocalScale(Vector3 value)
+  { Set<"localScale">(value); }
+  void SetLocalEulerAngles(Vector3 value)
+  { Set<"localEulerAngles">(value); }
+  void SetParent(Transform* parent, bool worldPositionStays)
+  { Call<"SetParent">(parent, worldPositionStays); }
+  void SetAsFirstSibling()
+  { Call<"SetAsFirstSibling">(); }
+  // A descendant by slash-separated path below this one, e.g. "Hint/Background".
+  Transform* Find(std::string_view path)
+  { return Call<"Find", Transform*>(il2cpp::NewString(path)); }
+
+  // This transform or the first descendant, depth first, whose GameObject is called `name`.
+  Transform* FindNamed(std::string_view name)
+  {
+    if (auto* object = gameObject(); object && object->NameIs(name))
+      return this;
+    for (int32_t i = 0; i < childCount(); ++i)
+      if (auto* child = GetChild(i); auto* found = child ? child->FindNamed(name) : nullptr)
+        return found;
+    return nullptr;
+  }
+
+  // The direct child whose GameObject is called `name`.
+  Transform* ChildNamed(std::string_view name)
+  {
+    for (int32_t i = 0; i < childCount(); ++i)
+      if (auto* child = GetChild(i); child && child->gameObject() && child->gameObject()->NameIs(name))
+        return child;
+    return nullptr;
+  }
+};
+
+struct RectTransform : Transform {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "RectTransform">;
+
+  Vector2 anchorMin()
+  { return Get<"anchorMin", Vector2>(); }
+  Vector2 anchorMax()
+  { return Get<"anchorMax", Vector2>(); }
+  Vector2 offsetMin()
+  { return Get<"offsetMin", Vector2>(); }
+  Vector2 offsetMax()
+  { return Get<"offsetMax", Vector2>(); }
+  void SetAnchorMin(Vector2 value)
+  { Set<"anchorMin">(value); }
+  void SetAnchorMax(Vector2 value)
+  { Set<"anchorMax">(value); }
+  void SetPivot(Vector2 value)
+  { Set<"pivot">(value); }
+  void SetOffsetMin(Vector2 value)
+  { Set<"offsetMin">(value); }
+  void SetOffsetMax(Vector2 value)
+  { Set<"offsetMax">(value); }
+
+  void Place(Vector2 anchor_min, Vector2 anchor_max, Vector2 pivot, Vector2 size, Vector2 position)
+  {
+    Set<"anchorMin">(anchor_min);
+    Set<"anchorMax">(anchor_max);
+    Set<"pivot">(pivot);
+    Set<"sizeDelta">(size);
+    Set<"anchoredPosition">(position);
+  }
+};
+
+// UnityEngine.Component, the base of every MonoBehaviour. Use As<Component>() on other bindings.
+struct Component : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Component">;
+
+  Transform* transform()
+  { return Get<"transform", Transform*>(); }
+  GameObject* gameObject()
+  { return Get<"gameObject", GameObject*>(); }
+};
+
+// A copy of `original` (a component copies its whole GameObject) under `parent`. Uses the non-generic
+// Instantiate(Object, Transform, bool): some clients expose the two-argument overload only as Instantiate<T>, which
+// would need generic inflation.
+template <typename T> T* Instantiate(T* original, Transform* parent, bool world_position_stays = false)
+{
+  return static_cast<T*>(ObjectClass::Call<"Instantiate", il2cpp::Object*(il2cpp::Object*, Transform*, bool)>(
+      original, parent, world_position_stays));
+}
+
+struct Behaviour : Component {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Behaviour">;
+
+  void SetEnabled(bool value)
+  { Set<"enabled">(value); }
+  bool isActiveAndEnabled()
+  { return Get<"isActiveAndEnabled", bool>(); }
+};
+
+struct Camera : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Camera">;
+
+  enum class ClearFlags : int32_t {
+    Skybox     = 1,
+    SolidColor = 2,
+    Depth      = 3,
+    Nothing    = 4,
+  };
+
+  void SetFarClipPlane(float value)
+  { Set<"farClipPlane">(value); }
+  void SetClearFlags(ClearFlags value)
+  { Set<"clearFlags">(value); }
+  void SetBackgroundColor(Color value)
+  { Set<"backgroundColor">(value); }
+};
+
+struct AnimationCurve : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "AnimationCurve">;
+  float Evaluate(float value)
+  { return Call<"Evaluate", float>(value); }
+};
+
+struct Shader : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Shader">;
+  std::string Name()
+  { return il2cpp::ToUtf8(Get<"name", Il2CppString*>()); }
+};
+
+struct Material : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Material">;
+  std::string Name()
+  { return il2cpp::ToUtf8(Get<"name", Il2CppString*>()); }
+  Shader* shader()
+  { return Get<"shader", Shader*>(); }
+  bool HasProperty(Il2CppString* name)
+  { return Call<"HasProperty", bool>(name); }
+  float GetFloat(Il2CppString* name)
+  { return Call<"GetFloat", float>(name); }
+  void SetFloat(Il2CppString* name, float value)
+  { Call<"SetFloat">(name, value); }
+};
+
+struct Renderer : Component {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Renderer">;
+  il2cpp::Array<Material*>* SharedMaterials()
+  { return Get<"sharedMaterials", il2cpp::Array<Material*>*>(); }
+};
+
+struct Canvas : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.UIModule", "UnityEngine", "Canvas">;
+};
+
+struct Screen {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Screen">;
+
+  static int32_t width()
+  { return Class::Get<"width", int32_t>(); }
+  static int32_t height()
+  { return Class::Get<"height", int32_t>(); }
+};
+
+using Cursor = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Cursor">;
+
+// UnityEngine.Time through its internal calls, which skip the managed wrappers.
+struct Time {
+  // -1 when Unity lacks the call.
+  static int32_t frameCount()
+  {
+    static const il2cpp::ICall<int32_t()> call{"UnityEngine.Time::get_frameCount()"};
+    return call ? call() : -1;
+  }
+  static float deltaTime()
+  {
+    static const il2cpp::ICall<float()> call{"UnityEngine.Time::get_deltaTime()"};
+    return call();
+  }
+};
+
+struct Texture2D : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Texture2D">;
+
+  int32_t width()
+  { return Get<"width", int32_t>(); }
+  int32_t height()
+  { return Get<"height", int32_t>(); }
+
+  // A texture decoded from PNG or JPG bytes, or null.
+  static Texture2D* Decode(const uint8_t* data, size_t size)
+  {
+    using ImageConversion = il2cpp::Class<"UnityEngine.ImageConversionModule", "UnityEngine", "ImageConversion">;
+    auto* bytes = data && size ? il2cpp::Array<uint8_t>::New(il2cpp::PrimitiveClass<uint8_t>(), size) : nullptr;
+    if (!bytes)
+      return nullptr;
+    std::memcpy(bytes->data(), data, size);
+    // Texture2D(width, height, TextureFormat.RGBA32, mipChain); LoadImage resizes it.
+    auto* texture = il2cpp::New<Texture2D>(int32_t{2}, int32_t{2}, int32_t{4}, false);
+    return texture && ImageConversion::Call<"LoadImage", bool>(texture, bytes, false) ? texture : nullptr;
+  }
+};
+
+struct Sprite : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Sprite">;
+
+  static Sprite* Create(Texture2D* texture, Rect rect, Vector2 pivot)
+  { return Class::Call<"Create", Sprite*>(texture, rect, pivot); }
+
+  float pixelsPerUnit()
+  { return Get<"pixelsPerUnit", float>(); }
+};
+} // namespace unity
diff --git a/mods/src/prime/KeyCode.h b/libs/unity/include/unity/input.h
similarity index 78%
rename from mods/src/prime/KeyCode.h
rename to libs/unity/include/unity/input.h
index 6f4c79fc2..15891a816 100644
--- a/mods/src/prime/KeyCode.h
+++ b/libs/unity/include/unity/input.h
@@ -1,5 +1,17 @@
 #pragma once
 
+// Keyboard and pointer input: Unity's KeyCode, the legacy Input API through its internal calls, a per-frame key
+// snapshot, text-field focus, and the Input System types bindings pass around.
+
+#include "core.h"
+
+#include <il2cpp/il2cpp.h>
+
+#include <cstdint>
+
+namespace unity
+{
+// UnityEngine.KeyCode.
 enum class KeyCode {
   None              = 0,
   Backspace         = 8,
@@ -328,6 +340,102 @@ enum class KeyCode {
   Joystick8Button18 = 508, // 0x000001FC
   Joystick8Button19 = 509, // 0x000001FD
 
-  // Autoamtic maximum
+  // One past the largest code, for tables indexed by key.
   Max
-};
\ No newline at end of file
+};
+
+// UnityEngine.Input through its internal calls, which skip the managed wrappers. A call that a Unity upgrade
+// renamed is reported once and then reads as nothing pressed.
+struct Input {
+  // True when Unity lacks the call, so a caller that skips key checks on idle frames still checks.
+  static bool anyKey()
+  {
+    static const il2cpp::ICall<bool()> call{"UnityEngine.Input::get_anyKey()"};
+    return !call || call();
+  }
+  static bool anyKeyDown()
+  {
+    static const il2cpp::ICall<bool()> call{"UnityEngine.Input::get_anyKeyDown()"};
+    return !call || call();
+  }
+  static bool GetKey(KeyCode key)
+  {
+    static const il2cpp::ICall<bool(KeyCode)> call{"UnityEngine.Input::GetKeyInt(UnityEngine.KeyCode)"};
+    return call(key);
+  }
+  static bool GetKeyDown(KeyCode key)
+  {
+    static const il2cpp::ICall<bool(KeyCode)> call{"UnityEngine.Input::GetKeyDownInt(UnityEngine.KeyCode)"};
+    return call(key);
+  }
+  static bool GetMouseButton(int32_t button)
+  {
+    static const il2cpp::ICall<bool(int32_t)> call{"UnityEngine.Input::GetMouseButton(System.Int32)"};
+    return call(button);
+  }
+  static int32_t touchCount()
+  {
+    static const il2cpp::ICall<int32_t()> call{"UnityEngine.Input::get_touchCount()"};
+    return call();
+  }
+  static Vector3 mousePosition()
+  {
+    static const il2cpp::ICall<void(Vector3*)> call{
+        "UnityEngine.Input::get_mousePosition_Injected(UnityEngine.Vector3&)"};
+    Vector3 position{};
+    call(&position);
+    return position;
+  }
+};
+
+enum class TouchPhase : int32_t {
+  Began      = 0,
+  Moved      = 1,
+  Stationary = 2,
+  Ended      = 3,
+  Canceled   = 4,
+};
+
+struct InputAction : il2cpp::Object {
+  using Class = il2cpp::Class<"Unity.InputSystem", "UnityEngine.InputSystem", "InputAction">;
+
+  Il2CppString* name()
+  { return Get<"name", Il2CppString*>(); }
+};
+
+struct InputActionReference : il2cpp::Object {
+  using Class = il2cpp::Class<"Unity.InputSystem", "UnityEngine.InputSystem", "InputActionReference">;
+
+  InputAction* action()
+  { return Get<"action", InputAction*>(); }
+};
+
+// UnityEngine.InputSystem.InputAction.CallbackContext, passed empty. Generated code takes it by value with the
+// platform's C++ ABI, so this layout must match the managed struct.
+struct InputActionCallbackContext {
+  void*   state;
+  int32_t action_index;
+};
+static_assert(sizeof(InputActionCallbackContext) == 16);
+
+// This frame's keyboard. Unity answers each key from its own per-frame state; the snapshot only skips asking on
+// idle frames and caches the derived checks.
+namespace Key
+{
+  // Starts a frame's reads. Every hook that reads keys calls it first, since hooks run in no fixed order within a
+  // frame and reads before it see the previous frame. Cheap after the first call in a frame.
+  void Poll();
+
+  // Held during this frame.
+  bool Pressed(KeyCode key);
+  // Went down this frame.
+  bool Down(KeyCode key);
+  // Any of Ctrl, Alt, AltGr, Shift, Cmd, or Win is held.
+  bool IsModified();
+
+  // A TextMeshPro input field has keyboard focus, so typing must not trigger shortcuts.
+  bool IsInputFocused();
+  // Takes keyboard focus away from the focused input field. Unity UI only does this on a click elsewhere.
+  void ClearInputFocus();
+} // namespace Key
+} // namespace unity
diff --git a/libs/unity/include/unity/tracker.h b/libs/unity/include/unity/tracker.h
new file mode 100644
index 000000000..5305d429a
--- /dev/null
+++ b/libs/unity/include/unity/tracker.h
@@ -0,0 +1,63 @@
+#pragma once
+
+// Live instances of chosen MonoBehaviour classes, found without asking Unity. Track<T>() detours T's constructor
+// and OnDestroy; a GC finalizer and Unity's liveness pass drop instances the game has released without destroying
+// them. Instances are borrowed: use them on the game thread, within the frame.
+
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
+
+#include <vector>
+
+namespace unity
+{
+namespace detail
+{
+  void Constructed(Il2CppObject* object);
+  void Destroyed(Il2CppObject* object);
+  // True the first time a native method is seen: constructors and OnDestroy often resolve to one shared base
+  // implementation, which must be detoured only once.
+  bool                       FirstDetour(void* native);
+  void                       StartTracking();
+  Il2CppObject*              Newest(Il2CppClass* klass);
+  std::vector<Il2CppObject*> Instances(Il2CppClass* klass);
+
+  inline void Ctor_Hook(auto original, Il2CppObject* _this, const MethodInfo* method)
+  {
+    original(_this, method);
+    Constructed(_this);
+  }
+
+  inline void OnDestroy_Hook(auto original, Il2CppObject* _this, const MethodInfo* method)
+  {
+    Destroyed(_this);
+    original(_this, method);
+  }
+} // namespace detail
+
+// Starts tracking T and its subclasses. Call while installing hooks, before T's instances are created: instances
+// that already exist are not found. Alternate parameterless lifecycle methods support pooled components.
+template <typename T> void Track(std::string_view created = ".ctor", std::string_view released = "OnDestroy")
+{
+  detail::StartTracking();
+  // Both lifecycle methods are parameterless; Unity's constructor and OnDestroy are the defaults.
+  if (auto ctor = T::Class::Method(created, 0); ctor && detail::FirstDetour(ctor.Pointer()))
+    IL2CPP_HOOK(ctor, detail::Ctor_Hook);
+  if (auto on_destroy = T::Class::Method(released, 0); on_destroy && detail::FirstDetour(on_destroy.Pointer()))
+    IL2CPP_HOOK(on_destroy, detail::OnDestroy_Hook);
+}
+
+// The newest live instance of T, or null. Only finds classes passed to Track.
+template <typename T> T* Newest()
+{ return static_cast<T*>(detail::Newest(T::Class::Raw())); }
+
+// Every live instance of T, oldest first. A copy, so the caller may call into the game while the GC's finalizer
+// thread keeps updating the tracker.
+template <typename T> std::vector<T*> Instances()
+{
+  std::vector<T*> result;
+  for (auto* object : detail::Instances(T::Class::Raw()))
+    result.push_back(static_cast<T*>(object));
+  return result;
+}
+} // namespace unity
diff --git a/libs/unity/include/unity/ui.h b/libs/unity/include/unity/ui.h
new file mode 100644
index 000000000..b56b0c4a2
--- /dev/null
+++ b/libs/unity/include/unity/ui.h
@@ -0,0 +1,217 @@
+#pragma once
+
+// Unity UI and TextMeshPro: canvases, images, buttons, toggles, text, input fields and the event system, plus the
+// small helpers for building UI from native code and keeping a decoded image alive across scene reloads.
+
+#include "core.h"
+
+#include <il2cpp/il2cpp.h>
+
+#include <cstdint>
+#include <string_view>
+
+namespace unity
+{
+struct CanvasScaler : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.UI", "CanvasScaler">;
+
+  // The property, which the scaler applies on its next Update; not the managed SetScaleFactor method, which writes
+  // Canvas.scaleFactor at once.
+  void SetScaleFactor(float value)
+  { Set<"scaleFactor">(value); }
+};
+
+// UnityEngine.UI.Image; color and raycastTarget come from Graphic.
+struct Image : Component {
+  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.UI", "Image">;
+
+  enum class Type : int32_t {
+    Simple = 0,
+    Sliced = 1,
+    Tiled  = 2,
+    Filled = 3,
+  };
+
+  Sprite* sprite()
+  { return Get<"sprite", Sprite*>(); }
+  void SetSprite(Sprite* value)
+  { Set<"sprite">(value); }
+  Sprite* overrideSprite()
+  { return Get<"overrideSprite", Sprite*>(); }
+  void SetOverrideSprite(Sprite* value)
+  { Set<"overrideSprite">(value); }
+  void SetType(Type value)
+  { Set<"type">(value); }
+  void SetPreserveAspect(bool value)
+  { Set<"preserveAspect">(value); }
+  void SetPixelsPerUnitMultiplier(float value)
+  { Set<"pixelsPerUnitMultiplier">(value); }
+  void SetColor(Color value)
+  { Set<"color">(value); }
+  void SetRaycastTarget(bool value)
+  { Set<"raycastTarget">(value); }
+  void SetVerticesDirty()
+  { Call<"SetVerticesDirty">(); }
+};
+
+struct Button : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.UI", "Button">;
+
+  void Press()
+  { Call<"Press">(); }
+};
+
+struct EventSystem : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.EventSystems", "EventSystem">;
+
+  static EventSystem* current()
+  { return Class::Get<"current", EventSystem*>(); }
+
+  GameObject* currentSelectedGameObject()
+  { return Get<"currentSelectedGameObject", GameObject*>(); }
+  void SetSelectedGameObject(GameObject* object)
+  { Call<"SetSelectedGameObject">(object); }
+};
+
+struct PointerEventData : il2cpp::Object {
+  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.EventSystems", "PointerEventData">;
+};
+
+struct Toggle : Component {
+  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.UI", "Toggle">;
+
+  bool isOn()
+  { return Get<"isOn", bool>(); }
+
+  // Goes through the pointer handler instead of the isOn setter, so interactable checks and listeners behave as for
+  // a real click.
+  void SimulateClick()
+  {
+    if (auto* event = il2cpp::New<PointerEventData>(EventSystem::current()))
+      Call<"OnPointerClick">(event);
+  }
+};
+
+struct TMP_Text : Component {
+  using Class = il2cpp::Class<"Unity.TextMeshPro", "TMPro", "TMP_Text">;
+
+  // TMPro.TextAlignmentOptions, the ones in use.
+  enum class Alignment : int32_t {
+    Left   = 0x201,
+    Center = 0x202,
+  };
+  // TMPro.TextOverflowModes, the ones in use.
+  enum class Overflow : int32_t {
+    Ellipsis = 1,
+  };
+
+  // TMP_FontAsset
+  il2cpp::Object* font()
+  { return Get<"font", il2cpp::Object*>(); }
+  void SetFont(il2cpp::Object* value)
+  { Set<"font">(value); }
+  void SetFontSize(float value)
+  { Set<"fontSize">(value); }
+  void SetAlignment(Alignment value)
+  { Set<"alignment">(value); }
+  void SetColor(Color value)
+  { Set<"color">(value); }
+  void SetRaycastTarget(bool value)
+  { Set<"raycastTarget">(value); }
+  void SetEnableWordWrapping(bool value)
+  { Set<"enableWordWrapping">(value); }
+  void SetRichText(bool value)
+  { Set<"richText">(value); }
+  void SetOverflowMode(Overflow value)
+  { Set<"overflowMode">(value); }
+  void SetEnableAutoSizing(bool value)
+  { Set<"enableAutoSizing">(value); }
+  void SetText(std::string_view value)
+  { Set<"text">(il2cpp::NewString(value)); }
+};
+
+struct TextMeshProUGUI : TMP_Text {
+  using Class = il2cpp::Class<"Unity.TextMeshPro", "TMPro", "TextMeshProUGUI">;
+};
+
+struct TMP_InputField : il2cpp::Object {
+  using Class = il2cpp::Class<"Unity.TextMeshPro", "TMPro", "TMP_InputField">;
+
+  bool isFocused()
+  { return Get<"isFocused", bool>(); }
+  void ActivateInputField()
+  { Call<"ActivateInputField">(); }
+};
+
+// The nearest ancestor of `transform` (or itself) with a Canvas, so an overlay attached there covers the screen.
+// `transform` when there is none.
+inline Transform* CanvasRoot(Transform* transform)
+{
+  for (auto* current = transform; current; current = current->parent())
+    if (auto* object = current->gameObject(); object && object->GetComponent<Canvas>())
+      return current;
+  return transform;
+}
+
+// An inactive GameObject with a RectTransform under `parent`, for building UI. `root` keeps it alive while the
+// caller builds it; once parented, the hierarchy owns it.
+inline RectTransform* CreateUiObject(std::string_view name, Transform* parent, il2cpp::GcHandle& root)
+{
+  auto* object = GameObject::Create(name);
+  root         = il2cpp::GcHandle::Strong(object);
+  if (!object)
+    return nullptr;
+  object->SetActive(false);
+  auto* transform = object->AddComponent<RectTransform>();
+  if (transform)
+    transform->SetParent(parent, false);
+  return transform;
+}
+
+// An image decoded once and kept while Unity keeps it: a scene reload unloads the texture, and the next use
+// decodes it again. Holds strong GC handles, so an instance must not outlive the runtime.
+class ImageAsset
+{
+public:
+  // Decodes `data` unless the texture is still loaded. False when it cannot be decoded.
+  bool Load(const uint8_t* data, size_t size)
+  {
+    if (Texture())
+      return true;
+    sprite_.Reset();
+    texture_ = il2cpp::GcHandle::Strong(Texture2D::Decode(data, size));
+    return Texture() != nullptr;
+  }
+
+  Texture2D* Texture() const
+  {
+    auto* texture = texture_.Get<Texture2D>();
+    return Alive(texture) ? texture : nullptr;
+  }
+
+  // A sprite over the whole texture, created on first use.
+  unity::Sprite* Sprite()
+  {
+    if (auto* sprite = sprite_.Get<unity::Sprite>(); Alive(sprite))
+      return sprite;
+    auto* texture = Texture();
+    if (!texture)
+      return nullptr;
+    const Rect rect{0.0f, 0.0f, static_cast<float>(texture->width()), static_cast<float>(texture->height())};
+    auto*      sprite = unity::Sprite::Create(texture, rect, Vector2{0.5f, 0.5f});
+    sprite_           = il2cpp::GcHandle::Strong(sprite);
+    return sprite;
+  }
+
+  // Height over width; 1 without a texture.
+  float AspectRatio() const
+  {
+    auto* texture = Texture();
+    return texture && texture->width() > 0 ? static_cast<float>(texture->height()) / texture->width() : 1.0f;
+  }
+
+private:
+  il2cpp::GcHandle texture_;
+  il2cpp::GcHandle sprite_;
+};
+} // namespace unity
diff --git a/libs/unity/src/input.cc b/libs/unity/src/input.cc
new file mode 100644
index 000000000..6d0d8fab7
--- /dev/null
+++ b/libs/unity/src/input.cc
@@ -0,0 +1,73 @@
+// Owns the per-frame keyboard snapshot and text-field focus.
+
+#include <unity/input.h>
+#include <unity/ui.h>
+
+#include <algorithm>
+#include <array>
+
+namespace unity
+{
+namespace
+{
+  // On an idle frame anyKey is false and no key is asked about at all; otherwise each key is one internal call.
+  struct Frame {
+    int    number   = -1;
+    bool   any_held = false;
+    bool   any_down = false;
+    int8_t focused  = 0; // 0 = not read yet, 1 = true, -1 = false
+    int8_t modified = 0;
+  } frame;
+
+  TMP_InputField* FocusedInputField()
+  {
+    auto* event_system = EventSystem::current();
+    auto* selected     = event_system ? event_system->currentSelectedGameObject() : nullptr;
+    auto* field        = selected ? selected->GetComponent<TMP_InputField>() : nullptr;
+    return field && field->isFocused() ? field : nullptr;
+  }
+} // namespace
+
+namespace Key
+{
+  void Poll()
+  {
+    // Without the frame count nothing is ever read: no key counts as pressed.
+    const int number = Time::frameCount();
+    if (number < 0 || number == frame.number)
+      return;
+    frame = {.number = number, .any_held = Input::anyKey(), .any_down = Input::anyKeyDown()};
+  }
+
+  bool Pressed(KeyCode key)
+  { return frame.any_held && Input::GetKey(key); }
+
+  bool Down(KeyCode key)
+  { return frame.any_down && Input::GetKeyDown(key); }
+
+  bool IsModified()
+  {
+    if (frame.modified == 0) {
+      constexpr std::array kModifiers{KeyCode::LeftAlt,      KeyCode::LeftControl,  KeyCode::LeftShift,
+                                      KeyCode::RightAlt,     KeyCode::RightControl, KeyCode::RightShift,
+                                      KeyCode::AltGr,        KeyCode::LeftCommand,  KeyCode::LeftWindows,
+                                      KeyCode::RightCommand, KeyCode::RightWindows};
+      frame.modified = frame.any_held && std::ranges::any_of(kModifiers, Pressed) ? 1 : -1;
+    }
+    return frame.modified == 1;
+  }
+
+  bool IsInputFocused()
+  {
+    if (frame.focused == 0)
+      frame.focused = FocusedInputField() ? 1 : -1;
+    return frame.focused == 1;
+  }
+
+  void ClearInputFocus()
+  {
+    if (FocusedInputField())
+      EventSystem::current()->SetSelectedGameObject(nullptr);
+  }
+} // namespace Key
+} // namespace unity
diff --git a/libs/unity/src/tracker.cc b/libs/unity/src/tracker.cc
new file mode 100644
index 000000000..65e341bc0
--- /dev/null
+++ b/libs/unity/src/tracker.cc
@@ -0,0 +1,192 @@
+// Owns the registry of tracked instances and the GC hooks that keep it honest.
+
+#include <unity/tracker.h>
+
+#include <il2cpp/hook.h>
+#include <spud/signature.h>
+
+#include <algorithm>
+#include <mutex>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace unity::detail
+{
+namespace
+{
+  // Borrowed pointers, keyed by class and every parent class, oldest first. The GC finalizer thread updates this,
+  // so every access holds the mutex. Never destroyed: the finalizer thread can still run while static destructors
+  // run at exit.
+  struct Registry {
+    std::mutex                                                   mutex;
+    std::unordered_map<Il2CppClass*, std::vector<Il2CppObject*>> objects;
+
+    std::vector<Il2CppObject*>* Find(Il2CppClass* klass)
+    {
+      const auto it = objects.find(klass);
+      return it == objects.end() ? nullptr : &it->second;
+    }
+  };
+  Registry& registry = *new Registry;
+
+  // While the GC marks, the low bit of an object's klass pointer is its mark bit.
+  Il2CppClass* ClassOf(Il2CppObject* object)
+  { return reinterpret_cast<Il2CppClass*>(reinterpret_cast<uintptr_t>(object->klass) & ~uintptr_t{1}); }
+
+  bool IsMarked(Il2CppObject* object)
+  { return (reinterpret_cast<uintptr_t>(object->klass) & 1) != 0; }
+
+  // Callers hold the registry lock. A base and a derived constructor can both be detoured and both run for one
+  // object, so tracking twice is a no-op; a second entry would outlive Untrack and hand out a freed object.
+  void Track(Il2CppObject* object)
+  {
+    auto& own = registry.objects[object->klass];
+    if (std::ranges::find(own, object) != own.end())
+      return;
+    for (auto* klass = object->klass; klass; klass = klass->parent)
+      registry.objects[klass].push_back(object);
+  }
+
+  void Untrack(Il2CppObject* object)
+  {
+    for (auto* klass = ClassOf(object); klass; klass = klass->parent)
+      if (auto* instances = registry.Find(klass))
+        std::erase(*instances, object);
+  }
+
+  // Unity's Boehm fork takes a per-entry "finalize mark proc" as a sixth argument. GC_finalize calls it for every
+  // unreachable finalized object, and the game's own registrations pass a no-op. Leaving the argument out puts
+  // register garbage in the entry, which GC_finalize later calls (seen as a call to null during
+  // ReclaimUnusedMemory).
+  void FinalizeMarkProcNoop(void*) {}
+
+  using FinalizerCallback = void (*)(void* object, void* client_data);
+  using RegisterFinalizer = void (*)(uintptr_t obj, FinalizerCallback fn, void* cd, FinalizerCallback* ofn, void** ocd,
+                                     void (*mark_proc)(void*));
+  // Not exported; found by its prologue. Null when the scan fails, and then only OnDestroy and the liveness pass
+  // untrack.
+  RegisterFinalizer register_finalizer = nullptr;
+
+  // A finalizer that was registered before ours, called after untracking.
+  struct ChainedFinalizer {
+    FinalizerCallback callback;
+    void*             data;
+  };
+
+  // Runs on the GC finalizer thread. `data` is the replaced finalizer, if the object had one.
+  void OnFinalize(void* object, void* data)
+  {
+    if (object) {
+      std::scoped_lock lock(registry.mutex);
+      Untrack(static_cast<Il2CppObject*>(object));
+    }
+    if (auto* chained = static_cast<ChainedFinalizer*>(data)) {
+      const auto next = *chained;
+      delete chained;
+      next.callback(object, next.data);
+    }
+  }
+
+  void WatchFinalizer(Il2CppObject* object)
+  {
+    if (!register_finalizer)
+      return;
+    const auto        address       = reinterpret_cast<uintptr_t>(object);
+    FinalizerCallback previous      = nullptr;
+    void*             previous_data = nullptr;
+    register_finalizer(address, OnFinalize, nullptr, &previous, &previous_data, FinalizeMarkProcNoop);
+    // An object has one finalizer slot. Ours is what reports the object gone, and the one it replaced must still
+    // run, so ours calls it. A base and a derived constructor can both register: then the slot already held ours,
+    // with any chain, and is put back as it was.
+    if (previous == OnFinalize)
+      register_finalizer(address, previous, previous_data, nullptr, nullptr, FinalizeMarkProcNoop);
+    else if (previous)
+      register_finalizer(address, OnFinalize, new ChainedFinalizer{previous, previous_data}, nullptr, nullptr,
+                         FinalizeMarkProcNoop);
+  }
+
+  // After Unity's liveness pass, objects still marked are unreachable from managed code; forget them before their
+  // native side goes away.
+  void LivenessFinalize_Hook(auto original, void* state)
+  {
+    original(state);
+
+    std::scoped_lock           lock(registry.mutex);
+    std::vector<Il2CppObject*> released;
+    // Every object sits in its own class's list, so checking those lists alone visits each object once.
+    for (auto& [klass, instances] : registry.objects)
+      for (auto* object : instances)
+        if (ClassOf(object) == klass && IsMarked(object))
+          released.push_back(object);
+    for (auto* object : released)
+      Untrack(object);
+  }
+
+  RegisterFinalizer FindRegisterFinalizer()
+  {
+#if _WIN32
+    auto matches = spud::find_in_module("40 56 57 41 57 48 83 EC ? 83 3D", "GameAssembly.dll");
+#elif SPUD_ARCH_ARM64
+    auto matches = spud::find_in_module(
+        "FF ? 02 D1 FC 6F ? A9 FA 67 ? A9 F8 5F ? A9 F6 57 ? A9 F4 4F ? A9 FD 7B ? A9 FD ? 02 91 E4 0F ? A9",
+        "GameAssembly.dylib");
+#else
+    auto matches = spud::find_in_module("55 48 89 E5 41 57 41 56 41 55 41 54 53 48 83 EC ? 4C 89 45 ? 48 89 4D ? 83 3D",
+                                        "GameAssembly.dylib");
+#endif
+    if (matches.empty()) {
+      il2cpp::Report("[Unity] GC_register_finalizer_inner not found; tracked objects are only dropped on OnDestroy "
+                     "and Unity's liveness pass");
+      return nullptr;
+    }
+    return reinterpret_cast<RegisterFinalizer>(matches.front().address());
+  }
+
+  std::unordered_set<void*> detoured;
+} // namespace
+
+void Constructed(Il2CppObject* object)
+{
+  if (!object || !object->klass)
+    return;
+  WatchFinalizer(object);
+  std::scoped_lock lock(registry.mutex);
+  Track(object);
+}
+
+void Destroyed(Il2CppObject* object)
+{
+  if (!object)
+    return;
+  std::scoped_lock lock(registry.mutex);
+  Untrack(object);
+}
+
+bool FirstDetour(void* native)
+{ return detoured.insert(native).second; }
+
+void StartTracking()
+{
+  static bool started = false;
+  if (std::exchange(started, true))
+    return;
+  IL2CPP_DETOUR(il2cpp_unity_liveness_finalize, LivenessFinalize_Hook, "il2cpp_unity_liveness_finalize");
+  register_finalizer = FindRegisterFinalizer();
+}
+
+Il2CppObject* Newest(Il2CppClass* klass)
+{
+  std::scoped_lock lock(registry.mutex);
+  auto*            objects = klass ? registry.Find(klass) : nullptr;
+  return objects && !objects->empty() ? objects->back() : nullptr;
+}
+
+std::vector<Il2CppObject*> Instances(Il2CppClass* klass)
+{
+  std::scoped_lock lock(registry.mutex);
+  auto*            objects = klass ? registry.Find(klass) : nullptr;
+  return objects ? *objects : std::vector<Il2CppObject*>{};
+}
+} // namespace unity::detail
diff --git a/libs/unity/xmake.lua b/libs/unity/xmake.lua
new file mode 100644
index 000000000..9ad245902
--- /dev/null
+++ b/libs/unity/xmake.lua
@@ -0,0 +1,7 @@
+target("unity")
+    set_kind("static")
+    add_files("src/*.cc")
+    add_includedirs("include", {public = true})
+    add_deps("il2cpp", {public = true})
+    add_packages("spud", {public = true})
+    set_exceptions("cxx")
diff --git a/macos-dylib/src/main.cc b/macos-dylib/src/main.cc
index 4b3be8119..136d69e13 100644
--- a/macos-dylib/src/main.cc
+++ b/macos-dylib/src/main.cc
@@ -1,25 +1,11 @@
-#include <stdio.h>
-#include <stdlib.h>
+// The macOS entry point: the loader injects this dylib into the game.
+
 #include <syslog.h>
-#include <unistd.h>
 
-#include "patches/patches.h"
+#include "mod.h"
 
-__attribute__((constructor))
-void myconstructor(int argc, const char **argv)
+__attribute__((constructor)) void InjectedConstructor(int, const char** argv)
 {
   syslog(LOG_ERR, "[+] dylib injected in %s\n", argv[0]);
-  ApplyPatches();
-}
-
-void* operator new[](size_t size, const char* /*name*/, int /*flags*/, unsigned /*debugFlags*/, const char* /*file*/,
-                     int /*line*/)
-{
-  return malloc(size);
-}
-
-void* operator new[](size_t size, size_t /*alignment*/, size_t /*alignmentOffset*/, const char* /*name*/, int /*flags*/,
-                     unsigned /*debugFlags*/, const char* /*file*/, int /*line*/)
-{
-  return malloc(size);
+  StartMod();
 }
diff --git a/mods/src/config.cc b/mods/src/config.cc
index 367441c34..154869b6c 100644
--- a/mods/src/config.cc
+++ b/mods/src/config.cc
@@ -1,69 +1,30 @@
 #include "config.h"
+
 #include "file.h"
-#include "patches/mapkey.h"
-#include "prime/KeyCode.h"
-#include "ship_name_match.h"
+#include "patches/shortcuts.h"
 #include "str_utils.h"
 #include "version.h"
-#include <prime/Toast.h>
 
-#include <EASTL/tuple.h>
+#include "prime/ui.h"
+
 #include <spdlog/spdlog.h>
+#include <toml++/toml.h>
 
-#include "defaultconfig.h"
 #include <algorithm>
-#include <array>
+#include <atomic>
+#include <chrono>
 #include <cmath>
-#include <cstdio>
-#include <initializer_list>
+#include <filesystem>
+#include <fstream>
 #include <iostream>
+#include <optional>
 #include <ranges>
-#include <string>
-#include <string_view>
-#include <utility>
-
-namespace DCP  = DefaultConfig::Patches;
-namespace DCA  = DefaultConfig::Audio;
-namespace DCG  = DefaultConfig::Graphics;
-namespace DCC  = DefaultConfig::Control;
-namespace DCU  = DefaultConfig::UI;
-namespace DCBS = DefaultConfig::Buffs;
-namespace DCS  = DefaultConfig::Sync;
-namespace DCSC = DefaultConfig::SystemConfig;
-namespace DCSH = DefaultConfig::Shortcuts;
+#include <tuple>
 
 namespace
 {
-constexpr bool is_all_audio_wildcard(std::string_view value)
-{
-  return value.size() == 3 && (value[0] == 'a' || value[0] == 'A') && (value[1] == 'l' || value[1] == 'L')
-         && (value[2] == 'l' || value[2] == 'L');
-}
-
-static_assert(is_all_audio_wildcard("aLl"));
-static_assert(!is_all_audio_wildcard(std::string_view{"All\0suffix", 10}));
-static_assert(!is_all_audio_wildcard(std::string_view{"\xffll", 3}));
-
-struct ToastAudioAlertConfig {
-  int                       toast_state;
-  std::string_view          config_name;
-  std::string_view          default_sound;
-  NotificationSound Config::* config_member;
-};
-
-constexpr auto kToastAudioAlerts = std::to_array<ToastAudioAlertConfig>({
-    {ToastState::Victory, "alert_victory", DCA::alert_victory, &Config::alert_victory},
-    {ToastState::Defeat, "alert_defeat", DCA::alert_defeat, &Config::alert_defeat},
-    {ToastState::ArmadaCreated, "alert_armada_created", DCA::alert_armada_created, &Config::alert_armada_created},
-    {ToastState::ArmadaBattleWon, "alert_armada_battle_won", DCA::alert_armada_battle_won,
-     &Config::alert_armada_battle_won},
-    {ToastState::ArmadaBattleLost, "alert_armada_battle_lost", DCA::alert_armada_battle_lost,
-     &Config::alert_armada_battle_lost},
-});
-} // namespace
-
-static const eastl::tuple<const char*, int> bannerTypes[] = {
-    {"All", ToastState::All},
+// Names of ToastState values as written in disabled_banner_types and notify_banner_types.
+constexpr std::pair<std::string_view, ToastState> kBannerTypes[] = {
     {"Standard", ToastState::Standard},
     {"FactionWarning", ToastState::FactionWarning},
     {"FactionLevelUp", ToastState::FactionLevelUp},
@@ -105,517 +66,173 @@ static const eastl::tuple<const char*, int> bannerTypes[] = {
     {"SurgeTimeLeft", ToastState::SurgeTimeLeft},
 };
 
-bool SyncConfig::enabled(SyncConfig::Type type) const
-{
-  for (const auto& opt : SyncOptions) {
-    if (opt.type == type) {
-      return this->*opt.option;
-    }
-  }
-
-  return false;
-}
-
-Config::Config()
-{
-  Load();
-}
-
-void Config::Save(const toml::table& config, const std::string_view filename, bool apply_warning)
-{
-  std::ofstream config_file;
-
-  auto config_path = File::MakePath(filename, true);
-  config_file.open(config_path);
-
-  if (apply_warning) {
-    char defaultFile[255], configFile[255];
-    snprintf(defaultFile, 255, "%s", File::Default());
-    snprintf(configFile, 255, "%s", File::Config());
-
-    config_file << "#######################################################################\n";
-    config_file << "#######################################################################\n";
-    config_file << "####                                                               ####\n";
-    config_file << "#### NOTE: This file is not the configuration file that is used    ####\n";
-    config_file << "####       by the STFC Community Mod.  It is provided to help      ####\n";
-    config_file << "####       see what configuration is being used by the runtime     ####\n";
-    config_file << "####       and any desired settings should be copied to the same   ####\n";
-    config_file << "####       section in: " << defaultFile << "\n";
-    config_file << "####                                                               ####\n";
-    config_file << "####        Config in: " << configFile << "\n";
-    config_file << "####                                                               ####\n";
-    config_file << "#######################################################################\n";
-    config_file << "#######################################################################\n\n";
-  }
-
-  config_file << config;
-  config_file.close();
-}
-
-Config& Config::Get()
-{
-  static Config config;
-  return config;
-}
-
-NotificationSound Config::NotificationSoundForToast(int toast_state) const
-{
-  const auto alert = std::ranges::find(kToastAudioAlerts, toast_state, &ToastAudioAlertConfig::toast_state);
-  return alert == kToastAudioAlerts.end() ? NotificationSound::None : this->*(alert->config_member);
-}
-
-MissionHudVisibility Config::MissionHudButtonVisibility(std::string_view button_name) const
-{
-  const auto it = this->mission_hud_buttons.find(std::string(button_name));
-  return it == this->mission_hud_buttons.end() ? MissionHudVisibility::Auto : it->second;
-}
-
-#if _WIN32
-static HMONITOR lastMonitor = (HMONITOR)-1;
-static float    dpi         = 1.0f;
-
-HWND Config::WindowHandle()
-{
-  static HWND hwnd = nullptr;
-
-  if (hwnd == nullptr) {
-    DWORD processId = GetCurrentProcessId();
-    hwnd            = GetTopWindow(nullptr); // Start with the first top-level window
-
-    while (hwnd != nullptr) {
-      DWORD windowProcessId;
-      GetWindowThreadProcessId(hwnd, &windowProcessId);
-
-      // Check if the window belongs to the current process and is the main window
-      if (windowProcessId == processId && GetWindow(hwnd, GW_OWNER) == nullptr && IsWindowVisible(hwnd)) {
-        break;
-      }
-
-      hwnd = GetNextWindow(hwnd, GW_HWNDNEXT); // Move to the next top-level window
-    }
-  }
-
-  return hwnd;
-}
-
-float Config::RefreshDPI()
-{
-  lastMonitor = (HMONITOR)-1;
-
-  return Config::GetDPI();
-}
-
-float Config::GetDPI()
-{
-  auto     activeWindow = GetActiveWindow();
-  HMONITOR monitor      = MonitorFromWindow(activeWindow, MONITOR_DEFAULTTONEAREST);
-
-  if (monitor != lastMonitor) {
-    // Get the logical width and height of the monitor
-    MONITORINFOEX monitorInfoEx;
-    monitorInfoEx.cbSize = sizeof(monitorInfoEx);
-    GetMonitorInfo(monitor, &monitorInfoEx);
-    auto cxLogical = monitorInfoEx.rcMonitor.right - monitorInfoEx.rcMonitor.left;
-    auto cyLogical = monitorInfoEx.rcMonitor.bottom - monitorInfoEx.rcMonitor.top;
-
-    // Get the physical width and height of the monitor
-    DEVMODE devMode;
-    devMode.dmSize        = sizeof(devMode);
-    devMode.dmDriverExtra = 0;
-    EnumDisplaySettings(monitorInfoEx.szDevice, ENUM_CURRENT_SETTINGS, &devMode);
-    auto cxPhysical = devMode.dmPelsWidth;
-    auto cyPhysical = devMode.dmPelsHeight;
-
-    // Calculate the scaling factor
-    auto horizontalScale = ((double)cxPhysical / (double)cxLogical);
-    auto verticalScale   = ((double)cyPhysical / (double)cyLogical);
-
-    spdlog::trace("Horizontal scaling: {}", horizontalScale);
-    spdlog::trace("Vertical scaling: {}", verticalScale);
-
-    dpi         = horizontalScale;
-    lastMonitor = monitor;
-  }
-
-  return dpi;
-}
-#else
-float Config::RefreshDPI()
-{
-  return Config::GetDPI();
-}
-
-float Config::GetDPI()
-{
-  return 1.0f;
-}
-#endif
-
-void Config::AdjustUiScale(bool scaleUp)
-{
-  if (this->ui_scale != 0.0f) {
-    auto old_scale    = this->ui_scale;
-    auto scale_factor = (scaleUp ? 1.0f : -1.0f) * this->ui_scale_step;
-    auto new_scale    = this->ui_scale + scale_factor;
-    this->ui_scale    = std::clamp(new_scale, 0.1f, 2.0f);
-
-    auto dpi = Config::RefreshDPI();
-    spdlog::info("UI has been scaled {}, was {}, now {} (unclamped {}) @ {} DPI Scaling", (scaleUp ? "UP" : "DOWN"),
-                 old_scale, this->ui_scale, new_scale, dpi);
-  }
-}
-
-void Config::AdjustUiViewerScale(bool scaleUp)
-{
-  if (this->ui_scale_viewer != 0.0f) {
-    auto old_scale        = this->ui_scale_viewer;
-    auto scale_factor     = (scaleUp ? 1.0f : -1.0f) * this->ui_scale_step;
-    auto new_scale        = this->ui_scale_viewer + (scale_factor * 0.25f);
-    this->ui_scale_viewer = std::clamp(new_scale, 0.1f, 2.0f);
-
-    spdlog::info("UI Viewer has been scaled {}, was {}, now {} (unclamped {})", (scaleUp ? "UP" : "DOWN"), old_scale,
-                 this->ui_scale_viewer, new_scale);
-  }
-}
-
-void Config::AdjustUiShipScale(bool scaleUp)
-{
-  const auto old_scale    = this->ui_scale_ship;
-  const auto scale_factor = (scaleUp ? 1.0f : -1.0f) * this->ui_scale_step;
-  const auto new_scale    = this->ui_scale_ship + scale_factor;
-  this->ui_scale_ship     = std::clamp(new_scale, 0.1f, 20.0f);
-
-  spdlog::info("System ship models have been scaled {}, was {}, now {} (unclamped {})", (scaleUp ? "UP" : "DOWN"),
-               old_scale, this->ui_scale_ship, new_scale);
-  ApplyUiShipScaleToLoadedShips(old_scale, this->ui_scale_ship);
-}
-
-inline std::string mask_token(const std::string& token)
-{
-  if (token.size() > 21) {
-    std::string masked = token;
-    for (size_t i = 9; i < token.size() - 12; ++i) {
-      if (masked[i] != '-') {
-        masked[i] = '*';
-      }
-    }
-    return masked;
-  }
-
-  return token;
-}
-
-std::string get_config_type_as_string(const toml::node_type type)
-{
-  switch (type) {
-    case toml::node_type::none:
-      return "Not-a-node.";
-    case toml::node_type::table:
-      return "toml::table.";
-    case toml::node_type::array:
-      return "toml::array.";
-    case toml::node_type::string:
-      return "toml::value<std::string>.";
-    case toml::node_type::integer:
-      return "toml::value<int64_t>.";
-    case toml::node_type::floating_point:
-      return "toml::value<double>.";
-    case toml::node_type::boolean:
-      return "toml::value<bool>.";
-    case toml::node_type::date:
-      return "toml::value<date>.";
-    case toml::node_type::time:
-      return "toml::value<time>.";
-    case toml::node_type::date_time:
-      return "toml::value<date_time>.";
-  };
-
-  return "The node type is unknown";
-}
-
-template <typename T>
-T get_config_or_default(toml::table& config, toml::table& new_config, std::string_view section, std::string_view item,
-                        T default_value, bool write_log)
-{
-  new_config.emplace<toml::table>(section, toml::table());
-
-  auto sectionTable = new_config[section];
-  T    final_value  = default_value;
-
-  try {
-    if (config.contains(section)) {
-      auto parsed_value = (T)config[section][item].value_or(default_value);
-      final_value       = parsed_value;
-    }
-  } catch (...) {
-    spdlog::warn("invalid config value {}.{}", section, item);
-  }
-
-  sectionTable.as_table()->insert_or_assign(item, final_value);
-
-  if (write_log) {
-    spdlog::debug("config value {}.{} value: {}", section, item, final_value);
-  }
-
-  return (T)final_value;
-}
-
-NotificationSound get_notification_sound(toml::table& config, toml::table& new_config, std::string_view item,
-                                         std::string_view default_value, bool write_log)
-{
-  const auto value = get_config_or_default<std::string>(config, new_config, "audio", item,
-                                                         std::string(default_value), false);
-  auto sound = notification_sound_from_name(StripAsciiWhitespace(value));
-  if (!sound.has_value()) {
-    spdlog::warn("invalid config value audio.{}: '{}'; using {}", item, value, default_value);
-    sound = notification_sound_from_name(default_value);
-  }
-
-  const auto result = sound.value_or(NotificationSound::None);
-  new_config["audio"].as_table()->insert_or_assign(item, notification_sound_name(result));
-  if (write_log) {
-    spdlog::debug("config value audio.{} value: {}", item, notification_sound_name(result));
-  }
-  return result;
-}
-
-template <typename T>
-T get_config_or_default_with_alias(toml::table& config, toml::table& new_config, std::string_view section,
-                                   std::string_view item, std::string_view alias, T default_value, bool write_log)
-{
-  if (!config[section][item] && config[section][alias]) {
-    config[section].as_table()->insert_or_assign(item, config[section][alias]);
-  }
-
-  return get_config_or_default(config, new_config, section, item, default_value, write_log);
-}
-
-std::string_view to_string(MissionHudVisibility visibility)
-{
-  switch (visibility) {
-    case MissionHudVisibility::Always:
-      return "always";
-    case MissionHudVisibility::Never:
-      return "never";
-    case MissionHudVisibility::Auto:
-    default:
-      return "auto";
-  }
-}
-
-MissionHudVisibility parse_mission_hud_visibility(std::string_view item, std::string_view value)
-{
-  const auto normalized = AsciiStrToUpper(StripAsciiWhitespace(value));
-
-  if (normalized == "ALWAYS") {
-    return MissionHudVisibility::Always;
-  }
-  if (normalized == "NEVER") {
-    return MissionHudVisibility::Never;
-  }
-  if (normalized == "AUTO" || normalized.empty()) {
-    return MissionHudVisibility::Auto;
-  }
-
-  spdlog::warn("invalid config value ui.{}: '{}'; using auto", item, value);
-  return MissionHudVisibility::Auto;
-}
-
-MissionHudVisibility get_mission_hud_visibility(toml::table& config, toml::table& new_config, std::string_view item,
-                                                std::string_view default_value, bool write_log)
-{
-  const auto value = config["ui"][item].value<std::string>().value_or(std::string(default_value));
-  const auto mode  = parse_mission_hud_visibility(item, value);
-
-  new_config.emplace<toml::table>("ui", toml::table());
-  new_config["ui"].as_table()->insert_or_assign(item, std::string(to_string(mode)));
+template <typename E> struct Choice {
+  std::string_view name;
+  E                value;
+};
 
-  if (write_log) {
-    spdlog::debug("config value ui.{} value: {}", item, to_string(mode));
-  }
+// The first name listed for a value is the one written back; later ones are accepted synonyms.
+constexpr Choice<MissionHudVisibility> kHudVisibility[] = {
+    {"auto", MissionHudVisibility::kAuto},
+    {"always", MissionHudVisibility::kAlways},
+    {"never", MissionHudVisibility::kNever},
+    {"", MissionHudVisibility::kAuto},
+};
 
-  return mode;
-}
+constexpr Choice<InstantWarpConfirmation> kInstantWarp[] = {
+    {"none", InstantWarpConfirmation::kNone},  {"warp", InstantWarpConfirmation::kWarp},
+    {"jump", InstantWarpConfirmation::kJump},  {"left", InstantWarpConfirmation::kWarp},
+    {"right", InstantWarpConfirmation::kJump}, {"", InstantWarpConfirmation::kNone},
+};
 
-std::string_view to_string(InstantWarpConfirmation confirmation)
-{
-  switch (confirmation) {
-    case InstantWarpConfirmation::Warp:
-      return "warp";
-    case InstantWarpConfirmation::Jump:
-      return "jump";
-    case InstantWarpConfirmation::None:
-    default:
-      return "none";
-  }
-}
+constexpr Choice<FleetLabelDetail> kFleetLabelDetail[] = {
+    {"native", FleetLabelDetail::kNative},    {"expanded", FleetLabelDetail::kExpanded},
+    {"compact", FleetLabelDetail::kCompact},  {"threshold", FleetLabelDetail::kThreshold},
+    {"always", FleetLabelDetail::kExpanded},  {"never", FleetLabelDetail::kCompact},
+    {"custom", FleetLabelDetail::kThreshold}, {"auto", FleetLabelDetail::kNative},
+    {"none", FleetLabelDetail::kNative},      {"off", FleetLabelDetail::kNative},
+    {"", FleetLabelDetail::kNative},
+};
 
-InstantWarpConfirmation parse_auto_confirm_instant_warp(std::string_view value)
+std::string MaskToken(const std::string& token)
 {
-  const auto normalized = AsciiStrToUpper(StripAsciiWhitespace(value));
-
-  if (normalized == "WARP" || normalized == "LEFT") {
-    return InstantWarpConfirmation::Warp;
-  }
-  if (normalized == "JUMP" || normalized == "RIGHT") {
-    return InstantWarpConfirmation::Jump;
-  }
-  if (normalized == "NONE" || normalized.empty()) {
-    return InstantWarpConfirmation::None;
-  }
-
-  spdlog::warn("invalid config value ui.auto_confirm_instant_warp: '{}'; using none", value);
-  return InstantWarpConfirmation::None;
+  if (token.size() <= 21)
+    return token;
+  auto masked = token;
+  for (size_t i = 9; i < token.size() - 12; ++i)
+    if (masked[i] != '-')
+      masked[i] = '*';
+  return masked;
 }
 
-InstantWarpConfirmation get_auto_confirm_instant_warp(toml::table& config, toml::table& new_config,
-                                                      std::string_view default_value, bool write_log)
+// Reads settings from the user's file and records every effective value in `parsed`, which is written out as the
+// runtime vars file so users can see what the mod actually used.
+class Reader
 {
-  const auto value = config["ui"]["auto_confirm_instant_warp"].value<std::string>().value_or(
-      std::string(default_value));
-  const auto confirmation = parse_auto_confirm_instant_warp(value);
-
-  new_config.emplace<toml::table>("ui", toml::table());
-  new_config["ui"].as_table()->insert_or_assign("auto_confirm_instant_warp", std::string(to_string(confirmation)));
-
-  if (write_log) {
-    spdlog::debug("config value ui.auto_confirm_instant_warp value: {}", to_string(confirmation));
+public:
+  Reader(const toml::table& config, toml::table& parsed, bool log)
+      : config_(config)
+      , parsed_(parsed)
+      , log_(log)
+  {
   }
 
-  return confirmation;
-}
-
-std::string_view to_string(FleetLabelDetail detail)
-{
-  switch (detail) {
-    case FleetLabelDetail::Expanded:
-      return "expanded";
-    case FleetLabelDetail::Compact:
-      return "compact";
-    case FleetLabelDetail::Threshold:
-      return "threshold";
-    case FleetLabelDetail::Native:
-    default:
-      return "native";
-  }
-}
+  const toml::table& Config() const
+  { return config_; }
 
-FleetLabelDetail parse_fleet_label_detail(std::string_view key, std::string_view value)
-{
-  const auto trimmed    = std::string(StripAsciiWhitespace(value));
-  const auto normalized = AsciiStrToUpper(trimmed);
+  toml::table& Section(std::string_view name)
+  { return *parsed_.emplace<toml::table>(name).first->second.as_table(); }
 
-  if (normalized == "EXPANDED" || normalized == "ALWAYS") {
-    return FleetLabelDetail::Expanded;
-  }
-  if (normalized == "COMPACT" || normalized == "NEVER") {
-    return FleetLabelDetail::Compact;
-  }
-  if (normalized == "THRESHOLD" || normalized == "CUSTOM") {
-    return FleetLabelDetail::Threshold;
-  }
-  if (normalized == "NATIVE" || normalized == "AUTO" || normalized == "NONE" || normalized == "OFF"
-      || normalized.empty()) {
-    return FleetLabelDetail::Native;
+  // The configured value converted to T, or `fallback` when missing or of the wrong type. TOML integers read fine
+  // into float settings; fractions into int settings do not.
+  template <typename T> T Get(std::string_view section, std::string_view key, T fallback)
+  {
+    T    value = fallback;
+    auto node  = config_[section][key];
+    if (auto read = node.template value<T>())
+      value = *read;
+    else if (node)
+      spdlog::warn("invalid config value {}.{}; using {}", section, key, fallback);
+    Record(section, key, value);
+    return value;
+  }
+
+  // Reads `key` into `value`, whose current value (the member's initializer) is the default.
+  template <typename T> void Read(std::string_view section, std::string_view key, T& value)
+  { value = Get(section, key, value); }
+
+  // A setting that was renamed: `key`, or `old_key` when only the old name is set. The vars file records `key`.
+  template <typename T>
+  void ReadRenamed(std::string_view section, std::string_view key, std::string_view old_key, T& value)
+  {
+    if (config_[section][key] || !config_[section][old_key])
+      return Read(section, key, value);
+    if (auto read = config_[section][old_key].template value<T>())
+      value = *read;
+    else
+      spdlog::warn("invalid config value {}.{}; using {}", section, old_key, value);
+    Record(section, key, value);
+  }
+
+  // A case-insensitive choice from a fixed list of names, read into `value`, whose current value is the default.
+  template <typename E, size_t N>
+  void Choose(std::string_view section, std::string_view key, E& value, const Choice<E> (&choices)[N])
+  {
+    const auto fallback   = Name(value, choices);
+    const auto raw        = Get<std::string>(section, key, std::string(fallback));
+    const auto normalized = AsciiStrToLower(StripAsciiWhitespace(raw));
+    const auto found      = std::ranges::find(choices, normalized, &Choice<E>::name);
+    if (found == std::end(choices))
+      spdlog::warn("invalid config value {}.{}: '{}'; using {}", section, key, raw, fallback);
+    else
+      value = found->value;
+    Record(section, key, std::string(Name(value, choices)));
+  }
+
+  template <typename T> void Record(std::string_view section, std::string_view key, const T& value)
+  {
+    Section(section).insert_or_assign(key, value);
+    if (log_)
+      spdlog::debug("config value {}.{} value: {}", section, key, value);
   }
 
-  spdlog::warn("invalid config value graphics.{}: '{}'; using native", key, value);
-  return FleetLabelDetail::Native;
-}
-
-FleetLabelDetail get_fleet_label_detail(toml::table& config, toml::table& new_config, std::string_view key,
-                                        std::string_view default_value, bool write_log)
-{
-  const auto value  = config["graphics"][key].value<std::string>().value_or(std::string(default_value));
-  const auto detail = parse_fleet_label_detail(key, value);
-
-  new_config.emplace<toml::table>("graphics", toml::table());
-  new_config["graphics"].as_table()->insert_or_assign(key, std::string(to_string(detail)));
+private:
+  // The canonical name: the first one listed for the value.
+  template <typename E, size_t N> static std::string_view Name(E value, const Choice<E> (&choices)[N])
+  { return std::ranges::find(choices, value, &Choice<E>::value)->name; }
 
-  if (write_log) {
-    spdlog::debug("config value graphics.{} value: {}", key, to_string(detail));
-  }
+  const toml::table& config_;
+  toml::table&       parsed_;
+  bool               log_;
+};
 
-  return detail;
-}
+// Sync options renamed since; their old names are still read, per target as well.
+constexpr std::pair<SyncConfig::Type, std::string_view> kRenamedSyncOptions[] = {
+    {SyncConfig::Type::kOfficer, "officer"}};
 
-float get_fleet_label_zoom_threshold(toml::table& config, toml::table& new_config, std::string_view key,
-                                     float default_value, bool write_log)
+std::string_view OldName(const SyncConfig::Option& option)
 {
-  auto threshold = config["graphics"][key].value<float>().value_or(default_value);
-  if (!std::isfinite(threshold) || threshold < 0.0f || threshold > 1.0f) {
-    spdlog::warn("invalid config value graphics.{}: {}; using {}", key, threshold, default_value);
-    threshold = default_value;
-  }
-
-  new_config.emplace<toml::table>("graphics", toml::table());
-  new_config["graphics"].as_table()->insert_or_assign(key, threshold);
-
-  if (write_log) {
-    spdlog::debug("config value graphics.{} value: {}", key, threshold);
-  }
-
-  return threshold;
+  const auto it =
+      std::ranges::find(kRenamedSyncOptions, option.type, &std::pair<SyncConfig::Type, std::string_view>::first);
+  return it == std::end(kRenamedSyncOptions) ? std::string_view{} : it->second;
 }
 
-void parse_ship_filter(std::string_view value, std::vector<std::string>& names, bool& match_all)
+// "*" matches every ship; otherwise a comma list of ship names, each split into words by ShipNameWords.
+ShipFilter ReadShipFilter(Reader& reader, std::string_view key)
 {
-  names.clear();
-  match_all = false;
-  if (AsciiStrToUpper(StripAsciiWhitespace(value)) == "*") {
-    match_all = true;
-    return;
-  }
-  for (const auto& token : StrSplit(std::string(value), ',')) {
-    auto stripped = StripAsciiWhitespace(token);
-    if (stripped.empty()) continue;
-    if (auto normalized = ShipNameMatch::NormalizeKey(stripped); !normalized.empty()) {
-      names.emplace_back(std::move(normalized));
-    }
-  }
+  const auto value = reader.Get<std::string>("ui", key, "");
+  ShipFilter filter;
+  filter.all = StripAsciiWhitespace(value) == "*";
+  if (!filter.all)
+    for (const auto& token : StrSplit(value, ','))
+      if (auto words = ShipNameWords(token); !words.empty())
+        filter.names.push_back(std::move(words));
+  return filter;
 }
 
-void read_instant_warp_filter(toml::table& config, toml::table& new_config, std::string_view key,
-                              std::vector<std::string>& names, bool& match_all,
-                              std::string_view default_value, bool write_log)
+std::vector<std::string> ReadFactions(Reader& reader)
 {
-  const auto value = config["ui"][key].value<std::string>().value_or(std::string(default_value));
-  parse_ship_filter(value, names, match_all);
+  static constexpr std::string_view kKnownFactions[] = {"federation", "klingon", "romulan"};
 
-  new_config.emplace<toml::table>("ui", toml::table());
-  new_config["ui"].as_table()->insert_or_assign(std::string(key), std::string(value));
-
-  if (write_log) {
-    spdlog::debug("config value ui.{}: {}", key, value);
+  std::vector<std::string> factions;
+  auto value = reader.Get<std::string>("ui", "daily_bulk_claim_factions", "federation,klingon,romulan");
+  if (StripAsciiWhitespace(value).empty()) {
+    value = "federation,klingon,romulan";
+    reader.Section("ui").insert_or_assign("daily_bulk_claim_factions", value);
   }
-}
-
-void parse_faction_filter(std::string_view value, std::vector<std::string>& factions)
-{
-  static constexpr std::array kKnownFactions{"federation", "klingon", "romulan"};
-
-  factions.clear();
   bool none = false;
-  for (const auto& token : StrSplit(std::string(value), ',')) {
-    const auto stripped = StripAsciiWhitespace(token);
-    if (stripped.empty())
-      continue;
-
-    auto lowered = AsciiStrToLower(std::string(stripped));
-
-    if (lowered == "none") {
+  for (const auto& token : StrSplit(value, ',')) {
+    auto faction = AsciiStrToLower(token);
+    if (faction == "none") {
       none = true;
       continue;
     }
-    if (std::ranges::find(kKnownFactions, lowered) == kKnownFactions.end()) {
+    if (std::ranges::find(kKnownFactions, faction) == std::end(kKnownFactions)) {
       spdlog::warn("Unrecognised faction '{}' in daily_bulk_claim_factions; expected one of: federation, klingon, "
                    "romulan, or none by itself. Ignoring.",
-                   stripped);
-      continue;
-    }
-
-    if (std::ranges::find(factions, lowered) == factions.end()) {
-      factions.emplace_back(std::move(lowered));
+                   token);
+    } else if (std::ranges::find(factions, faction) == factions.end()) {
+      factions.push_back(std::move(faction));
     }
   }
   if (none) {
@@ -623,985 +240,507 @@ void parse_faction_filter(std::string_view value, std::vector<std::string>& fact
       spdlog::warn("daily_bulk_claim_factions: none overrides named factions; use none by itself.");
     factions = {"none"};
   }
+  return factions;
 }
 
-void read_daily_bulk_claim_factions(toml::table& config, toml::table& new_config, std::vector<std::string>& factions,
-                                    std::string_view default_value, bool write_log)
+// A comma list of banner names, or "All". The vars file gets the names that matched.
+std::vector<int> ReadBannerTypes(Reader& reader, std::string_view key)
 {
-  auto value = config["ui"]["daily_bulk_claim_factions"].value<std::string>().value_or(std::string(default_value));
-  // Blank has the same meaning as an omitted setting. Materialize the default
-  // for both gameplay and generated config values; none is the explicit opt-out.
-  if (StripAsciiWhitespace(value).empty())
-    value = std::string(default_value);
-  parse_faction_filter(value, factions);
-
-  new_config.emplace<toml::table>("ui", toml::table());
-  new_config["ui"].as_table()->insert_or_assign("daily_bulk_claim_factions", std::string(value));
+  std::vector<std::string> wanted;
+  for (const auto& token : StrSplit(reader.Get<std::string>("ui", key, ""), ','))
+    wanted.push_back(AsciiStrToUpper(token));
+  const bool all = std::erase(wanted, "ALL") > 0;
 
-  if (write_log) {
-    spdlog::debug("config value ui.daily_bulk_claim_factions: {}", value);
+  std::vector<int> types;
+  std::string      names;
+  for (const auto& [name, state] : kBannerTypes) {
+    if (!all && std::erase(wanted, AsciiStrToUpper(name)) == 0)
+      continue;
+    types.push_back(static_cast<int>(state));
+    names += names.empty() ? "" : ", ";
+    names += name;
   }
+  for (const auto& unknown : wanted)
+    spdlog::warn("Unknown banner type '{}' in ui.{}", unknown, key);
+
+  reader.Record("ui", key, names);
+  return types;
 }
 
-void read_sync_targets(toml::table& config, toml::table& new_config,
-                       std::map<std::string, SyncTargetConfig>& sync_targets, const SyncConfig& defaults)
+void ReadSyncTargets(Reader& reader, std::map<std::string, SyncTargetConfig>& sync_targets, const SyncConfig& defaults)
 {
-  if (!config.contains("sync")) {
-    return;
-  }
-
-  const auto sync = config["sync"].as_table();
-  if (!sync || !sync->contains("targets")) {
-    return;
-  }
+  // The built-in targets are listed in the vars file as examples; they only sync once given a token.
+  auto& parsed_targets =
+      *reader.Section("sync")
+           .insert_or_assign(
+               "targets",
+               toml::table{
+                   {"stfcdata", toml::table{{"token", ""}, {"url", "https://sync.stfcdata.de"}}},
+                   {"nextspocksclub", toml::table{{"token", ""}, {"url", "https://next.spocks.club/sync/ingress/"}}},
+                   {"spocksclub", toml::table{{"token", ""}, {"url", "https://spocks.club/sync/ingress/"}}},
+               })
+           .first->second.as_table();
 
-  const auto targets = config["sync"]["targets"].as_table();
-  if (!targets) {
+  const auto* targets = reader.Config()["sync"]["targets"].as_table();
+  if (!targets)
     return;
-  }
 
-  for (const auto& [target_key, target_config] : *targets) {
-    if (!target_config.is_table()) {
+  for (const auto& [name, node] : *targets) {
+    const auto* values = node.as_table();
+    if (!values)
       continue;
-    }
 
-    const std::string target_section = "sync.targets." + std::string(target_key.str());
-
-    SyncTargetConfig target;
-    toml::table      parsed_target;
-
-    const auto& values = *target_config.as_table();
-    if (values.contains("url") && values.contains("token")) {
-      auto url   = values["url"].value<std::string>();
-      auto token = values["token"].value<std::string>();
-      auto proxy = values["proxy"].value<std::string>();
-
-      if (!url.has_value() || !token.has_value() || url->empty() || token->empty()) {
-        continue;
-      }
-
-      target.url        = url.value();
-      target.token      = token.value();
-      target.proxy      = proxy.value_or(defaults.proxy);
-      target.verify_ssl = values["verify_ssl"].value<bool>().value_or(defaults.verify_ssl);
-
-      parsed_target.insert("url", target.url);
-      parsed_target.insert("token", target.token);
-      parsed_target.insert("proxy", target.proxy);
-      parsed_target.insert("verify_ssl", target.verify_ssl);
-    } else {
-      spdlog::warn("Skipping invalid target [{}]. Missing url or token.", target_section);
+    const auto section = "sync.targets." + std::string(name.str());
+    if (!values->contains("url") || !values->contains("token")) {
+      spdlog::warn("Skipping invalid target [{}]. Missing url or token.", section);
       continue;
     }
+    const auto url   = (*values)["url"].value<std::string>();
+    const auto token = (*values)["token"].value<std::string>();
+    if (!url || !token || url->empty() || token->empty())
+      continue;
 
-    for (const auto& opt : SyncOptions) {
-      if (opt.type == SyncConfig::Type::Officer && !values.contains(opt.option_str)) {
-        target.*opt.option = values["officer"].value<bool>().value_or(defaults.*opt.option);
-      } else {
-        target.*opt.option = values[opt.option_str].value<bool>().value_or(defaults.*opt.option);
-      }
-      parsed_target.insert(opt.option_str, target.*opt.option);
+    SyncTargetConfig target;
+    target.url        = *url;
+    target.token      = *token;
+    target.proxy      = (*values)["proxy"].value<std::string>().value_or(defaults.proxy);
+    target.verify_ssl = (*values)["verify_ssl"].value<bool>().value_or(defaults.verify_ssl);
+
+    toml::table parsed{
+        {"url", target.url}, {"token", target.token}, {"proxy", target.proxy}, {"verify_ssl", target.verify_ssl}};
+    for (const auto& option : SyncOptions) {
+      const auto key =
+          !values->contains(option.option_str) && !OldName(option).empty() ? OldName(option) : option.option_str;
+      target.*option.option = (*values)[key].value<bool>().value_or(defaults.*option.option);
+      parsed.insert(option.option_str, target.*option.option);
     }
 
-    if (sync_targets.emplace(target_key.str(), target).second) {
-      new_config["sync"]["targets"].as_table()->insert_or_assign(target_key.str(), parsed_target);
-      spdlog::debug("config value {} url: {}, token: {}", target_section, target.url, mask_token(target.token));
-      spdlog::info("target [{}] proxy: '{}', verify_ssl: {}", target_section, target.proxy, target.verify_ssl);
+    if (sync_targets.emplace(name.str(), target).second) {
+      parsed_targets.insert_or_assign(name.str(), std::move(parsed));
+      spdlog::debug("config value {} url: {}, token: {}", section, target.url, MaskToken(target.token));
+      spdlog::info("target [{}] proxy: '{}', verify_ssl: {}", section, target.proxy, target.verify_ssl);
     }
   }
 }
 
-struct ShortcutConfigValue {
-  std::string value;
-  std::string source_item;
-  bool        from_config = false;
-  bool        valid_type  = true;
-};
-
-std::string shortcut_source_label(const ShortcutConfigValue& shortcut_value, std::string_view item)
+void Save(const toml::table& table, const std::string& name, bool warning_header)
 {
-  if (!shortcut_value.valid_type) {
-    return "invalid";
-  }
-  if (!shortcut_value.from_config) {
-    return "default";
-  }
-  if (shortcut_value.source_item == item) {
-    return "config";
+  std::ofstream file(File::Path(name, true));
+  if (warning_header) {
+    file << "#######################################################################\n";
+    file << "#######################################################################\n";
+    file << "####                                                               ####\n";
+    file << "#### NOTE: This file is not the configuration file that is used    ####\n";
+    file << "####       by the STFC Community Mod.  It is provided to help      ####\n";
+    file << "####       see what configuration is being used by the runtime     ####\n";
+    file << "####       and any desired settings should be copied to the same   ####\n";
+    file << "####       section in: " << File::DefaultConfig() << "\n";
+    file << "####                                                               ####\n";
+    file << "####        Config in: " << File::Config() << "\n";
+    file << "####                                                               ####\n";
+    file << "#######################################################################\n";
+    file << "#######################################################################\n\n";
   }
-
-  std::string label = "alias:";
-  label.append(shortcut_value.source_item);
-  return label;
-}
-
-void set_shortcut_source(toml::node_view<toml::node> sourceTable, std::string_view item, std::string_view source)
-{
-  sourceTable.as_table()->insert_or_assign(item, std::string(source));
-}
-
-void set_shortcut_noop(toml::node_view<toml::node> sectionTable, toml::node_view<toml::node> sourceTable,
-                       std::string_view item, std::string_view source)
-{
-  sectionTable.as_table()->insert_or_assign(item, "NONE");
-  set_shortcut_source(sourceTable, item, source);
-  spdlog::debug("shortcut value shortcuts.{} value: NONE", item);
+  file << table;
 }
+} // namespace
 
-void parse_config_shortcut_value(toml::table& new_config, std::string_view item, GameFunction gameFunction,
-                                 std::string_view default_value, const ShortcutConfigValue& shortcut_value)
+bool SyncConfig::enabled(SyncConfig::Type type) const
 {
-  auto section = "shortcuts";
-  auto source  = "shortcuts_source";
-
-  new_config.emplace<toml::table>(section, toml::table());
-  new_config.emplace<toml::table>(source, toml::table());
-
-  auto sectionTable = new_config[section];
-  auto sourceTable  = new_config[source];
-  auto sourceLabel  = shortcut_source_label(shortcut_value, item);
-
-  if (!shortcut_value.valid_type) {
-    spdlog::error("Invalid shortcut value [shortcuts].{} must be a string; using default for [shortcuts].{}.",
-                  shortcut_value.source_item, item);
-    return parse_config_shortcut_value(new_config, item, gameFunction, default_value,
-                                       {std::string(default_value), std::string(item), false, true});
-  }
-
-  auto config_value = shortcut_value.value;
-  auto valueTrimmed = StripTrailingAsciiWhitespace(config_value);
-  auto valueLowered = AsciiStrToUpper(valueTrimmed);
-
-  // An explicit empty string disables the binding, just like NONE. Missing or
-  // invalid settings still fall back to their defaults.
-  if (valueTrimmed.empty() || valueLowered == "NONE") {
-    set_shortcut_noop(sectionTable, sourceTable, item, sourceLabel);
-    return;
-  }
-
-  auto wantedKeys = StrSplit(valueLowered, '|');
-
-  bool keyAdded = false;
-  for (std::string_view wantedKey : wantedKeys) {
-    MapKey mapKey = MapKey::Parse(wantedKey);
-
-    if (mapKey.Key != KeyCode::None) {
-      keyAdded = true;
-      MapKey::AddMappedKey(gameFunction, std::move(mapKey));
-    } else if (!wantedKey.empty()) {
-      spdlog::warn("Invalid shortcut token [shortcuts].{} token='{}' value='{}'; ignoring token.",
-                   shortcut_value.source_item, wantedKey, config_value);
-    }
-  }
-
-  if (!keyAdded) {
-    if (shortcut_value.from_config) {
-      spdlog::error("No valid shortcut tokens for [shortcuts].{} value='{}'; using default for [shortcuts].{}.",
-                    shortcut_value.source_item, config_value, item);
-      return parse_config_shortcut_value(new_config, item, gameFunction, default_value,
-                                         {std::string(default_value), std::string(item), false, true});
-    } else {
-      spdlog::error("Default shortcut [shortcuts].{} value='{}' has no valid tokens; action disabled.", item,
-                    config_value);
-    }
-    set_shortcut_noop(sectionTable, sourceTable, item, "invalid");
-    return;
-  }
-
-  auto shortcut = MapKey::GetShortcuts(gameFunction);
-  sectionTable.as_table()->insert_or_assign(item, shortcut);
-  set_shortcut_source(sourceTable, item, sourceLabel);
-
-  spdlog::debug("shortcut value {}.{} value: {}", section, item, shortcut);
+  for (const auto& opt : SyncOptions)
+    if (opt.type == type)
+      return this->*opt.option;
+  return false;
 }
 
-bool shortcut_key_exists(toml::table& config, std::string_view item)
-{
-  auto shortcuts = config["shortcuts"].as_table();
-  return shortcuts && shortcuts->contains(item);
-}
+// The settings file as parsed. `loaded` is false when it was missing or did not parse and defaults are used.
+struct SettingsFile {
+  toml::table table;
+  bool        loaded = false;
+};
 
-ShortcutConfigValue get_shortcut_value_or_default(toml::table& config, std::string_view item,
-                                                  std::string_view default_value)
+namespace
 {
-  if (!shortcut_key_exists(config, item)) {
-    return {std::string(default_value), std::string(item), false, true};
-  }
-
-  auto value = config["shortcuts"][item].value<std::string>();
-  if (!value) {
-    return {"", std::string(item), true, false};
-  }
-
-  return {*value, std::string(item), true, true};
-}
+// The current settings. Replaced settings are never freed: a sync thread may still be reading them, and they only
+// pile up as fast as someone edits the file.
+std::atomic<Config*> current_config{nullptr};
 
-void parse_config_shortcut(toml::table& config, toml::table& new_config, std::string_view item,
-                           GameFunction gameFunction, std::string_view default_value)
+toml::table ParseSettingsFile()
 {
-  auto section = "shortcuts";
-
-  config.emplace<toml::table>(section, toml::table());
-
-  parse_config_shortcut_value(new_config, item, gameFunction, default_value,
-                              get_shortcut_value_or_default(config, item, default_value));
+  const auto path = File::Path(File::Config()).u8string();
+  return toml::parse_file(std::string_view(reinterpret_cast<const char*>(path.data()), path.size()));
 }
+} // namespace
 
-void parse_config_shortcut_aliases(toml::table& config, toml::table& new_config, std::string_view item,
-                                   GameFunction gameFunction, std::string_view default_value,
-                                   std::initializer_list<std::string_view> aliases)
+Config& Config::Get()
 {
-  auto section = "shortcuts";
-
-  config.emplace<toml::table>(section, toml::table());
-
-  auto       config_value = get_shortcut_value_or_default(config, item, default_value);
-  const auto has_item     = shortcut_key_exists(config, item);
-
-  for (const auto alias : aliases) {
-    if (!shortcut_key_exists(config, alias)) {
-      continue;
-    }
-
-    if (has_item) {
-      spdlog::warn("Ignoring deprecated shortcut alias [shortcuts].{} because [shortcuts].{} is set.", alias, item);
-      continue;
+  if (auto* config = current_config.load(std::memory_order_acquire))
+    return *config;
+  // First use, inside il2cpp_init on the game thread. A broken file falls back to the defaults here.
+  static Config* const first = [] {
+    File::MigrateLegacyFiles();
+    SettingsFile file;
+    try {
+      file.table  = ParseSettingsFile();
+      file.loaded = true;
+    } catch (const toml::parse_error& e) {
+      spdlog::warn("Failed to load config file, falling back to default settings: {}", e.description());
+    } catch (...) {
+      spdlog::warn("Failed to load config file, falling back to default settings");
     }
-
-    config_value = get_shortcut_value_or_default(config, alias, default_value);
-    spdlog::warn("Deprecated shortcut alias [shortcuts].{} is supported for compatibility; use [shortcuts].{}.",
-                 alias, item);
-    break;
-  }
-
-  parse_config_shortcut_value(new_config, item, gameFunction, default_value, config_value);
+    auto* config = new Config;
+    config->Load(file, true);
+    current_config.store(config, std::memory_order_release);
+    return config;
+  }();
+  return *first;
 }
 
-void migrate_mac_config_if_needed(const char* filename)
+bool Config::Reload()
 {
-#if !_WIN32
-  namespace fs = std::filesystem;
+  SettingsFile file;
+  try {
+    file.table  = ParseSettingsFile();
+    file.loaded = true;
+  } catch (const toml::parse_error& e) {
+    spdlog::warn("Settings not reloaded, {} does not parse: {}", File::Config(), e.description());
+    return false;
+  } catch (const std::exception& e) {
+    spdlog::warn("Settings not reloaded, {} could not be read: {}", File::Config(), e.what());
+    return false;
+  }
 
-  fs::path file_path = File::MakePath(filename);
-  auto     new_dir   = file_path.parent_path();
-  if (fs::exists(file_path) || fs::exists(new_dir))
+  spdlog::info("Reloading settings from {}", File::Config());
+  auto* next = new Config;
+  try {
+    next->Load(file, false);
+  } catch (const std::exception& e) {
+    // Shortcuts may already be rebound from the new file; everything else keeps the current settings.
+    spdlog::error("Settings not reloaded: {}", e.what());
+    delete next;
+    return false;
+  }
+  // Hooks are installed once, so the startup hook groups stay in force.
+  if (!(next->patches == Get().patches))
+    spdlog::warn("Changes to [patches] take effect after a restart");
+  next->patches = Get().patches;
+  current_config.store(next, std::memory_order_release);
+  return true;
+}
+
+void Config::ReloadIfChanged()
+{
+  // Editors save in steps (truncate, then write) and an empty file is valid TOML, so a change is only applied once
+  // the file has kept the same modification time for a whole check.
+  using Clock = std::chrono::steady_clock;
+  static Clock::time_point                              next_check{};
+  static std::optional<std::filesystem::file_time_type> applied, pending;
+
+  const auto now = Clock::now();
+  if (now < next_check)
     return;
+  next_check = now + std::chrono::seconds(1);
 
-  spdlog::info("mac config migration: config dir does not exist, checking for migration...");
-
-  fs::path old_path = File::MakePath(filename, false, true);
-  if (!fs::exists(old_path)) {
-    spdlog::info("mac config migration: old config does not exist. nothing to migrate.");
+  std::error_code error;
+  const auto      time = std::filesystem::last_write_time(File::Path(File::Config()), error);
+  if (error)
+    return;
+  if (!applied || time == *applied) {
+    applied = time;
+    pending.reset();
     return;
   }
-
-  auto stat = fs::status(old_path);
-  if (stat.type() == fs::file_type::regular) {
-    spdlog::info("mac config migration: old config found. attempting to migrate...");
-
-    try {
-      // move
-      auto old_dir = old_path.parent_path();
-      fs::rename(old_dir, new_dir);
-
-      // re-create old dir, create symlink
-      fs::create_directories(old_dir);
-      fs::create_symlink(file_path, old_path);
-
-      // drop update-info.txt
-      std::ofstream info;
-      info.open(old_dir / "update-info.txt");
-      info << "Your config has been moved!\n\n";
-      info << "You can now find your config at " << file_path << "\n\n";
-      info << "A symlink has been placed for your convenience, but it is generally recommended, that you use the new "
-              "path and delete this directory going forward.";
-      info.close();
-
-      spdlog::info("mac config migration: config migration done.");
-    } catch (std::exception& ex) {
-      spdlog::warn("mac config migration: migration failed = {}", ex.what());
-    }
+  if (pending != time) {
+    pending = time;
+    return;
   }
-#endif
+  applied = time;
+  pending.reset();
+  Reload();
 }
 
-void delete_old_vars()
+MissionHudVisibility Config::Ui::MissionHudButtonVisibility(std::string_view button) const
 {
-  namespace fs = std::filesystem;
-
-  fs::path        old_vars = fs::path(File::MakePath(File::Vars())).parent_path() / FILE_DEF_VARS_OLD;
-  std::error_code ignore;
-  fs::remove(old_vars, ignore);
+  const auto it = mission_hud_buttons.find(button);
+  return it == mission_hud_buttons.end() ? MissionHudVisibility::kAuto : it->second;
 }
 
-void Config::Load()
+void Config::Load(const SettingsFile& file, bool first)
 {
-  auto filename = File::Config();
-
-  migrate_mac_config_if_needed(filename);
-  delete_old_vars();
-
-  toml::table config;
+  const auto& config = file.table;
   toml::table parsed;
-  bool        write_config = false;
-  bool        write_log    = true;
-  try {
-    config       = std::move(toml::parse_file(File::MakePath(filename)));
-    write_config = true;
-  } catch (const toml::parse_error& e) {
-    spdlog::warn("Failed to load config file, falling back to default settings: {}", e.description());
-    spdlog::debug("");
-    write_config = false;
-    write_log    = false;
-  } catch (...) {
-    spdlog::warn("Failed to load config file, falling back to default settings");
-    spdlog::debug("");
-    write_config = false;
-    write_log    = false;
-  }
-
-  // Patch switches are honoured in release builds too (previously debug-only):
-  // needed to selectively disable hook groups that collide with BepInEx plugins
-  // hooking the same il2cpp methods (native + managed detour on one prologue crashes).
-  this->installUiScaleHooks =
-      get_config_or_default(config, parsed, "patches", "uiscalehooks", DCP::uiscalehooks, write_config);
-  this->installZoomHooks = get_config_or_default(config, parsed, "patches", "zoomhooks", DCP::zoomhooks, write_config);
-  this->installHavenZoomHooks =
-      get_config_or_default(config, parsed, "patches", "havenzoomhooks", DCP::havenzoomhooks, write_config);
-  this->installInteriorZoomHooks =
-      get_config_or_default(config, parsed, "patches", "interiorzoomhooks", DCP::interiorzoomhooks, write_config);
-  this->installBuffFixHooks =
-      get_config_or_default(config, parsed, "patches", "bufffixhooks", DCP::bufffixhooks, write_config);
-  this->installToastBannerHooks =
-      get_config_or_default(config, parsed, "patches", "toastbannerhooks", DCP::toastbannerhooks, write_config);
-  this->installPanHooks = get_config_or_default(config, parsed, "patches", "panhooks", DCP::panhooks, write_config);
-  this->installHotkeyHooks =
-      get_config_or_default(config, parsed, "patches", "hotkeyhooks", DCP::hotkeyhooks, write_config);
-  this->installFreeResizeHooks =
-      get_config_or_default(config, parsed, "patches", "freeresizehooks", DCP::freeresizehooks, write_config);
-  this->installTempCrashFixes =
-      get_config_or_default(config, parsed, "patches", "tempcrashfixes", DCP::tempcrashfixes, write_config);
-  this->installTestPatches =
-      get_config_or_default(config, parsed, "patches", "testpatches", DCP::testpatches, write_config);
-  this->installMiscPatches =
-      get_config_or_default(config, parsed, "patches", "miscpatches", DCP::miscpatches, write_config);
-  this->installMissionHudTweaksHooks =
-      get_config_or_default(config, parsed, "patches", "missionhudtweakshooks", DCP::missionhudtweakshooks, write_config);
-  this->installChatPatches =
-      get_config_or_default(config, parsed, "patches", "chatpatches", DCP::chatpatches, write_config);
-  this->installPlayerTitleDisplayHooks = get_config_or_default(config, parsed, "patches", "chattitledisplayhooks",
-                                                               DCP::chattitledisplayhooks, write_config);
-  this->installSyncPatches =
-      get_config_or_default(config, parsed, "patches", "syncpatches", DCP::syncpatches, write_config);
-  this->installGameVersionHook =
-      get_config_or_default(config, parsed, "patches", "game_version", DCP::game_version, write_config);
-  this->installObjectTracker =
-      get_config_or_default(config, parsed, "patches", "objecttracker", DCP::objecttracker, write_config);
-  this->installLoadingScreenHooks =
-      get_config_or_default(config, parsed, "patches", "loadingscreenhooks", DCP::loadingscreenhooks, write_config);
-  this->installTransitionScreenHooks =
-      get_config_or_default(config, parsed, "patches", "transitionscreenhooks", DCP::transitionscreenhooks, write_config);
-  this->installGiftsBulkClaimHooks =
-      get_config_or_default(config, parsed, "patches", "giftsbulkclaimhooks", DCP::giftsbulkclaimhooks, write_config);
-  this->installDailyFactionBulkClaimHooks = get_config_or_default(
-      config, parsed, "patches", "dailyfactionbulkclaimhooks", DCP::dailyfactionbulkclaimhooks, write_config);
-  this->installGalacticAnomalyTimerHooks =
-      get_config_or_default(config, parsed, "patches", "galacticanomalytimerhooks", DCP::galacticanomalytimerhooks, write_config);
-  this->installLoadingTipHooks =
-      get_config_or_default(config, parsed, "patches", "loadingtiphooks", DCP::loadingtiphooks, write_config);
-  this->installDoubleClickAssignShipHooks =
-      get_config_or_default(config, parsed, "patches", "doubleclickassignshiphooks", DCP::doubleclickassignshiphooks, write_config);
-  this->installForbiddenTechConfirmationHooks =
-      get_config_or_default(config, parsed, "patches", "forbiddentechconfirmhooks", DCP::forbiddentechconfirmhooks, write_config);
-  this->installForbiddenTechShipNameHooks = get_config_or_default(
-      config, parsed, "patches", "forbiddentechshipnamehooks", DCP::forbiddentechshipnamehooks, write_config);
-  this->installRevealConfirmationHooks =
-      get_config_or_default(config, parsed, "patches", "revealconfirmhooks", DCP::revealconfirmhooks, write_config);
-  this->installQueueAddressGuardHooks = get_config_or_default(
-      config, parsed, "patches", "queueaddressguardhooks", DCP::queueaddressguardhooks, write_config);
-  this->installActionQueueRecoveryHooks =
-      get_config_or_default(config, parsed, "patches", "actionqueuerecoveryhooks", DCP::actionqueuerecoveryhooks, write_config);
-  this->installThinQueueProtectionHooks =
-      get_config_or_default(config, parsed, "patches", "thinqueueprotectionhooks", DCP::thinqueueprotectionhooks, write_config);
-  this->installArtifactExchangeHooks =
-      get_config_or_default(config, parsed, "patches", "artifactexchangehooks", DCP::artifactexchangehooks, write_config);
-  this->installAudioEventHooks =
-      get_config_or_default(config, parsed, "patches", "audioeventhooks", DCP::audioeventhooks, write_config);
-  this->installInstantCargoCounterHooks =
-      get_config_or_default(config, parsed, "patches", "instantcargocounterhooks", DCP::instantcargocounterhooks, write_config);
-  this->installCargoFormatHooks =
-      get_config_or_default(config, parsed, "patches", "cargoformathooks", DCP::cargoformathooks, write_config);
-  this->installOfficerSortHooks =
-      get_config_or_default(config, parsed, "patches", "officersorthooks", DCP::officersorthooks, write_config);
-  this->installPinnedShipSortHooks =
-      get_config_or_default(config, parsed, "patches", "pinnedshiphooks", DCP::pinnedshiphooks, write_config);
-  this->installPinnedShipClickToggle = get_config_or_default(config, parsed, "patches", "pinnedshipclicktoggle",
-                                                             DCP::pinnedshipclicktoggle, write_config);
-  this->installAllianceGamesStoreHooks = get_config_or_default(
-      config, parsed, "patches", "alliancegamesstorehooks", DCP::alliancegamesstorehooks, write_config);
-  this->installHavenHistoryHooks =
-      get_config_or_default(config, parsed, "patches", "havenhistoryhooks", DCP::havenhistoryhooks, write_config);
-  spdlog::debug("");
-  this->kirshara_fixes = get_config_or_default(config, parsed, "control", "kirshara_fixes",
-                                             DCC::kirshara_fixes, write_config);
+  Reader      r(config, parsed, file.loaded);
+  r.Read("graphics", "interior_zoom_scale", graphics.interior_zoom_scale);
+  if (!std::isfinite(graphics.interior_zoom_scale) || graphics.interior_zoom_scale < 1.0f) {
+    spdlog::warn("invalid graphics.interior_zoom_scale {}; using 2", graphics.interior_zoom_scale);
+    graphics.interior_zoom_scale = 2.0f;
+    r.Record("graphics", "interior_zoom_scale", graphics.interior_zoom_scale);
+  }
+  r.Read("control", "kirshara_fixes", control.kirshara_fixes);
   if (!config["control"]["kirshara_fixes"]
       && (config["control"]["faster_queue_recovery"] || config["control"]["thin_queue_protection"]
           || config["control"]["queue_address_guard"] || config["advanced"]["queue"]["thin_queue_protection"]))
     spdlog::warn("The separate queue feature settings have been replaced by [control] kirshara_fixes (default=true). "
                  "Set kirshara_fixes=false to disable the combined fixes; old feature settings are ignored.");
-  this->queue_enabled =
-      get_config_or_default(config, parsed, "control", "queue_enabled", DCC::queue_enabled, write_config);
-  this->hotkeys_enabled =
-      get_config_or_default(config, parsed, "control", "hotkeys_enabled", DCC::hotkeys_enabled, write_config);
-  this->hotkeys_extended =
-      get_config_or_default(config, parsed, "control", "hotkeys_extended", DCC::hotkeys_extended, write_config);
-  this->primary_requires_visible_target = get_config_or_default(
-      config, parsed, "control", "primary_requires_visible_target", DCC::primary_requires_visible_target, write_config);
-  this->use_scopely_hotkeys =
-      get_config_or_default(config, parsed, "control", "use_scopely_hotkeys", DCC::use_scopely_hotkeys, write_config);
-  this->select_timer =
-      get_config_or_default(config, parsed, "control", "select_timer", DCC::select_timer, write_config);
-  this->enable_experimental =
-      get_config_or_default(config, parsed, "control", "enable_experimental", DCC::enable_experimental, write_config);
-
-  spdlog::debug("");
-
-  this->ui_scale = get_config_or_default(config, parsed, "graphics", "ui_scale", DCG::ui_scale, write_config);
-  this->ui_scale_step = get_config_or_default_with_alias(config, parsed, "graphics", "ui_scale_step", "ui_scale_adjust",
-                                                         DCG::ui_scale_step, write_config);
-  this->ui_scale_ship =
-      get_config_or_default(config, parsed, "graphics", "ui_scale_ship", DCG::ui_scale_ship, write_config);
-  this->ui_scale_viewer =
-      get_config_or_default(config, parsed, "graphics", "ui_scale_viewer", DCG::ui_scale_viewer, write_config);
-  this->zoom     = get_config_or_default(config, parsed, "graphics", "zoom", DCG::zoom, write_config);
-  this->haven_zoom = get_config_or_default(config, parsed, "graphics", "haven_zoom", DCG::haven_zoom, write_config);
-  if (!std::isfinite(this->haven_zoom) || this->haven_zoom < 0.0f) {
-    spdlog::warn("Invalid haven_zoom {}; using {}", this->haven_zoom, DCG::haven_zoom);
-    this->haven_zoom = DCG::haven_zoom;
-    parsed["graphics"].as_table()->insert_or_assign("haven_zoom", this->haven_zoom);
-  }
-  this->interior_zoom_scale =
-      get_config_or_default(config, parsed, "graphics", "interior_zoom_scale", DCG::interior_zoom_scale, write_config);
-  if (!std::isfinite(this->interior_zoom_scale) || this->interior_zoom_scale < 1.0f) {
-    spdlog::warn("Invalid interior_zoom_scale {}; using {}", this->interior_zoom_scale, DCG::interior_zoom_scale);
-    this->interior_zoom_scale = DCG::interior_zoom_scale;
-    parsed["graphics"].as_table()->insert_or_assign("interior_zoom_scale", this->interior_zoom_scale);
-  }
-  this->fr_scale = get_config_or_default(config, parsed, "graphics", "fr_scale", DCG::fr_scale, write_config);
-  this->zoom_label_player.detail =
-      get_fleet_label_detail(config, parsed, "zoom_label_player_detail", DCG::zoom_label_player_detail, write_config);
-  this->zoom_label_player.zoom_threshold = get_fleet_label_zoom_threshold(
-      config, parsed, "zoom_label_player_threshold", DCG::zoom_label_player_threshold, write_config);
-  this->zoom_label_non_player.detail         = get_fleet_label_detail(config, parsed, "zoom_label_non_player_detail",
-                                                                      DCG::zoom_label_non_player_detail, write_config);
-  this->zoom_label_non_player.zoom_threshold = get_fleet_label_zoom_threshold(
-      config, parsed, "zoom_label_non_player_threshold", DCG::zoom_label_non_player_threshold, write_config);
-  this->free_resize = get_config_or_default(config, parsed, "graphics", "free_resize", DCG::free_resize, write_config);
-  this->allow_cursor =
-      get_config_or_default(config, parsed, "graphics", "allow_cursor", DCG::allow_cursor, write_config);
-  this->keyboard_zoom_speed =
-      get_config_or_default(config, parsed, "graphics", "keyboard_zoom_speed", DCG::keyboard_zoom_speed, write_config);
-
-  if (this->enable_experimental) {
-    this->system_pan_momentum = get_config_or_default(config, parsed, "graphics", "system_pan_momentum",
-                                                      DCG::system_pan_momentum, write_config);
-  }
-
-  spdlog::debug("");
-
-  this->system_pan_momentum_falloff = get_config_or_default(config, parsed, "graphics", "system_pan_momentum_falloff",
-                                                            DCG::system_pan_momentum_falloff, write_log);
-  this->disable_target_camera_lock = get_config_or_default(config, parsed, "graphics", "disable_target_camera_lock",
-                                                         DCG::disable_target_camera_lock, write_log);
-  this->borderless_fullscreen =
-      get_config_or_default(config, parsed, "graphics", "borderless_fullscreen", DCG::borderless_fullscreen, write_log);
-  this->transition_time =
-      get_config_or_default(config, parsed, "graphics", "transition_time", DCG::transition_time, write_config);
-  this->default_system_zoom =
-      get_config_or_default(config, parsed, "graphics", "default_system_zoom", DCG::default_system_zoom, write_config);
-
-  spdlog::debug("");
-
-  this->system_zoom_preset_1   = get_config_or_default(config, parsed, "graphics", "system_zoom_preset_1",
-                                                       DCG::system_zoom_preset_1, write_config);
-  this->system_zoom_preset_2   = get_config_or_default(config, parsed, "graphics", "system_zoom_preset_2",
-                                                       DCG::system_zoom_preset_2, write_config);
-  this->system_zoom_preset_3   = get_config_or_default(config, parsed, "graphics", "system_zoom_preset_3",
-                                                       DCG::system_zoom_preset_3, write_config);
-  this->system_zoom_preset_4   = get_config_or_default(config, parsed, "graphics", "system_zoom_preset_4",
-                                                       DCG::system_zoom_preset_4, write_config);
-  this->system_zoom_preset_5   = get_config_or_default(config, parsed, "graphics", "system_zoom_preset_5",
-                                                       DCG::system_zoom_preset_5, write_config);
-  this->use_presets_as_default = get_config_or_default(config, parsed, "graphics", "use_presets_as_default",
-                                                       DCG::use_presets_as_default, write_config);
-
-  spdlog::debug("");
-
-  this->use_out_of_dock_power = get_config_or_default(config, parsed, "buffs", "use_out_of_dock_power",
-                                                      DCBS::use_out_of_dock_power, write_config);
-
-  spdlog::debug("");
-
-  this->disable_escape_exit =
-      get_config_or_default(config, parsed, "ui", "disable_escape_exit", DCU::disable_escape_exit, write_config);
-  this->disable_escape_exit_timer = get_config_or_default(config, parsed, "ui", "disable_escape_exit_timer",
-                                                          DCU::disable_escape_exit_timer, write_config);
-  this->disable_preview_locate =
-      get_config_or_default(config, parsed, "ui", "disable_preview_locate", DCU::disable_preview_locate, write_config);
-  this->disable_preview_recall =
-      get_config_or_default(config, parsed, "ui", "disable_preview_recall", DCU::disable_preview_recall, write_config);
-  this->only_show_first_popup = get_config_or_default(config, parsed, "ui", "only_show_first_popup",
-                                                      DCU::only_show_first_popup, write_config);
-  this->disable_move_keys =
-      get_config_or_default(config, parsed, "ui", "disable_move_keys", DCU::disable_move_keys, write_config);
-  this->disable_toast_banners =
-      get_config_or_default(config, parsed, "ui", "disable_toast_banners", DCU::disable_toast_banners, write_config);
-  this->trace_audio_events =
-      get_config_or_default(config, parsed, "audio", "trace_events", DCA::trace_events, write_config);
-  auto disabled_audio_events = get_config_or_default<std::string>(
-      config, parsed, "audio", "disabled_events", DCA::disabled_events, write_config);
-  this->disable_all_audio_events = false;
-  this->disabled_audio_events.clear();
-  for (const auto& event : StrSplit(disabled_audio_events, ',')) {
-    auto stripped = StripAsciiWhitespace(event);
-    if (is_all_audio_wildcard(stripped)) {
-      this->disable_all_audio_events = true;
-    } else if (!stripped.empty()) {
-      this->disabled_audio_events.emplace_back(stripped);
+  r.Read("control", "primary_requires_visible_target", control.primary_requires_visible_target);
+  r.Read("ui", "show_player_title", ui.show_player_title);
+  r.Read("ui", "auto_confirm_reveal_ability", ui.auto_confirm_reveal_ability);
+  r.Read("ui", "dock_syncmanagement", ui.dock_syncmanagement);
+  r.Read("patches", "interiorzoomhooks", patches.interiorzoomhooks);
+  r.Read("patches", "chattitledisplayhooks", patches.chattitledisplayhooks);
+  r.Read("patches", "revealconfirmhooks", patches.revealconfirmhooks);
+  r.Read("patches", "actionqueuerecoveryhooks", patches.actionqueuerecoveryhooks);
+  r.Read("patches", "queueaddressguardhooks", patches.queueaddressguardhooks);
+  r.Read("patches", "thinqueueprotectionhooks", patches.thinqueueprotectionhooks);
+  r.Read("patches", "pinnedshipclicktoggle", patches.pinnedshipclicktoggle);
+
+  // [patches] toggles are read in every build: they let users disable hook groups that collide with BepInEx
+  // plugins hooking the same IL2CPP methods (a native and a managed detour on one prologue crash).
+  for (auto [key, value] : std::initializer_list<std::pair<const char*, bool*>>{
+           {"uiscalehooks", &patches.uiscalehooks},
+           {"zoomhooks", &patches.zoomhooks},
+           {"havenzoomhooks", &patches.havenzoomhooks},
+           {"havenhistoryhooks", &patches.havenhistoryhooks},
+           {"alliancegamesstorehooks", &patches.alliancegamesstorehooks},
+           {"bufffixhooks", &patches.bufffixhooks},
+           {"toastbannerhooks", &patches.toastbannerhooks},
+           {"panhooks", &patches.panhooks},
+           {"hotkeyhooks", &patches.hotkeyhooks},
+           {"freeresizehooks", &patches.freeresizehooks},
+           {"tempcrashfixes", &patches.tempcrashfixes},
+           {"testpatches", &patches.testpatches},
+           {"miscpatches", &patches.miscpatches},
+           {"missionhudtweakshooks", &patches.missionhudtweakshooks},
+           {"chatpatches", &patches.chatpatches},
+           {"syncpatches", &patches.syncpatches},
+           {"game_version", &patches.game_version},
+           {"objecttracker", &patches.objecttracker},
+           {"loadingscreenhooks", &patches.loadingscreenhooks},
+           {"transitionscreenhooks", &patches.transitionscreenhooks},
+           {"giftsbulkclaimhooks", &patches.giftsbulkclaimhooks},
+           {"dailyfactionbulkclaimhooks", &patches.dailyfactionbulkclaimhooks},
+           {"galacticanomalytimerhooks", &patches.galacticanomalytimerhooks},
+           {"loadingtiphooks", &patches.loadingtiphooks},
+           {"doubleclickassignshiphooks", &patches.doubleclickassignshiphooks},
+           {"forbiddentechconfirmhooks", &patches.forbiddentechconfirmhooks},
+           {"forbiddentechshipnamehooks", &patches.forbiddentechshipnamehooks},
+           {"audioeventhooks", &patches.audioeventhooks},
+           {"instantcargocounterhooks", &patches.instantcargocounterhooks},
+           {"cargoformathooks", &patches.cargoformathooks},
+           {"officersorthooks", &patches.officersorthooks},
+           {"pinnedshiphooks", &patches.pinnedshiphooks},
+           {"artifactexchangehooks", &patches.artifactexchangehooks},
+       })
+    r.Read("patches", key, *value);
+
+  r.Read("control", "queue_enabled", control.queue_enabled);
+  r.Read("control", "hotkeys_enabled", control.hotkeys_enabled);
+  r.Read("control", "hotkeys_extended", control.hotkeys_extended);
+  r.Read("control", "use_scopely_hotkeys", control.use_scopely_hotkeys);
+  r.Read("control", "select_timer", control.select_timer);
+  r.Read("control", "enable_experimental", control.enable_experimental);
+
+  auto& g = graphics;
+  r.Read("graphics", "ui_scale", g.ui_scale);
+  r.ReadRenamed("graphics", "ui_scale_step", "ui_scale_adjust", g.ui_scale_step);
+  r.Read("graphics", "ui_scale_ship", g.ui_scale_ship);
+  r.Read("graphics", "ui_scale_viewer", g.ui_scale_viewer);
+  r.Read("graphics", "zoom", g.zoom);
+  r.Read("graphics", "haven_zoom", g.haven_zoom);
+  if (!std::isfinite(g.haven_zoom) || g.haven_zoom < 0.0f) {
+    spdlog::warn("invalid g.haven_zoom {}; using 4000", g.haven_zoom);
+    g.haven_zoom = 4000.0f;
+    r.Record("graphics", "haven_zoom", g.haven_zoom);
+  }
+  r.Read("graphics", "fr_scale", g.fr_scale);
+  for (auto [profile, prefix] : {std::pair{&g.zoom_label_player, std::string("zoom_label_player")},
+                                 std::pair{&g.zoom_label_non_player, std::string("zoom_label_non_player")}}) {
+    const auto fallback = profile->zoom_threshold;
+    r.Choose("graphics", prefix + "_detail", profile->detail, kFleetLabelDetail);
+    r.Read("graphics", prefix + "_threshold", profile->zoom_threshold);
+    if (!std::isfinite(profile->zoom_threshold) || profile->zoom_threshold < 0.0f || profile->zoom_threshold > 1.0f) {
+      spdlog::warn("invalid config value graphics.{}_threshold: {}; using {}", prefix, profile->zoom_threshold,
+                   fallback);
+      profile->zoom_threshold = fallback;
+      r.Record("graphics", prefix + "_threshold", fallback);
     }
   }
-  bool any_toast_audio_alert_configured = false;
-  for (const auto& alert : kToastAudioAlerts) {
-    const auto sound = get_notification_sound(config, parsed, alert.config_name, alert.default_sound, write_config);
-    this->*(alert.config_member) = sound;
-    any_toast_audio_alert_configured |= sound != NotificationSound::None;
-  }
-  if (!this->installToastBannerHooks && any_toast_audio_alert_configured) {
+  r.Read("graphics", "free_resize", g.free_resize);
+  r.Read("graphics", "allow_cursor", g.allow_cursor);
+  r.Read("graphics", "keyboard_zoom_speed", g.keyboard_zoom_speed);
+  if (control.enable_experimental)
+    r.Read("graphics", "system_pan_momentum", g.system_pan_momentum);
+  r.Read("graphics", "system_pan_momentum_falloff", g.system_pan_momentum_falloff);
+  r.Read("graphics", "disable_target_camera_lock", g.disable_target_camera_lock);
+  r.Read("graphics", "borderless_fullscreen", g.borderless_fullscreen);
+  r.Read("graphics", "transition_time", g.transition_time);
+  r.Read("graphics", "default_system_zoom", g.default_system_zoom);
+  r.Read("graphics", "system_zoom_preset_1", g.system_zoom_preset_1);
+  r.Read("graphics", "system_zoom_preset_2", g.system_zoom_preset_2);
+  r.Read("graphics", "system_zoom_preset_3", g.system_zoom_preset_3);
+  r.Read("graphics", "system_zoom_preset_4", g.system_zoom_preset_4);
+  r.Read("graphics", "system_zoom_preset_5", g.system_zoom_preset_5);
+  r.Read("graphics", "use_presets_as_default", g.use_presets_as_default);
+  r.Read("graphics", "loader_enabled", g.loader_enabled);
+  r.Read("graphics", "loader_transition", g.loader_transition);
+  r.Read("graphics", "loader_transition_black", g.loader_transition_black);
+  // Without transition customization (or in a build that keeps the original background) the game's own black
+  // background stays. The vars file records what is actually used.
+#ifdef _USE_ORIGINAL_BG
+  constexpr bool kOriginalBackground = true;
+#else
+  constexpr bool kOriginalBackground = false;
+#endif
+  if (kOriginalBackground || !g.loader_transition) {
+    g.loader_transition_black = true;
+    r.Record("graphics", "loader_transition_black", true);
+  }
+  r.Read("graphics", "loader_image", g.loader_image);
+  r.Read("graphics", "loader_logo_scale", g.loader_logo_scale);
+  r.Read("graphics", "loader_tip_enabled", g.loader_tip_enabled);
+  r.Read("graphics", "galactic_anomaly_timer", g.galactic_anomaly_timer);
+
+  r.Read("buffs", "use_out_of_dock_power", buffs.use_out_of_dock_power);
+
+  r.Read("audio", "trace_events", audio.trace_events);
+  audio.disable_all_events = false;
+  audio.disabled_events.clear();
+  for (const auto& event : StrSplit(r.Get<std::string>("audio", "disabled_events", ""), ',')) {
+    if (AsciiStrToLower(event) == "all")
+      audio.disable_all_events = true;
+    else
+      audio.disabled_events.push_back(event);
+  }
+  bool has_audio_alert = false;
+  for (auto [key, value] : std::initializer_list<std::pair<const char*, NotificationSound*>>{
+           {"alert_victory", &audio.alert_victory},
+           {"alert_defeat", &audio.alert_defeat},
+           {"alert_armada_created", &audio.alert_armada_created},
+           {"alert_armada_battle_won", &audio.alert_armada_battle_won},
+           {"alert_armada_battle_lost", &audio.alert_armada_battle_lost}}) {
+    const auto name  = r.Get<std::string>("audio", key, "none");
+    const auto sound = notification_sound_from_name(StripAsciiWhitespace(name));
+    if (!sound)
+      spdlog::warn("invalid config value audio.{}: '{}'; using none", key, name);
+    *value = sound.value_or(NotificationSound::None);
+    r.Record("audio", key, notification_sound_name(*value));
+    has_audio_alert |= *value != NotificationSound::None;
+  }
+  if (has_audio_alert && !patches.toastbannerhooks)
     spdlog::warn("audio alerts require patches.toastbannerhooks = true");
-  }
-  this->auto_open_bulk_claim_flyout = get_config_or_default(config, parsed, "ui", "auto_open_bulk_claim_flyout",
-                                                            DCU::auto_open_bulk_claim_flyout, write_config);
-
-  read_daily_bulk_claim_factions(config, parsed, this->daily_bulk_claim_factions, DCU::daily_bulk_claim_factions,
-                                 write_config);
-  this->daily_bulk_claim_toggle_default_on =
-      get_config_or_default(config, parsed, "ui", "daily_bulk_claim_toggle_default_on",
-                            DCU::daily_bulk_claim_toggle_default_on, write_config);
-  this->auto_confirm_instant_warp =
-      get_auto_confirm_instant_warp(config, parsed, DCU::auto_confirm_instant_warp, write_config);
-  this->installInstantWarpConfirmationHooks = true;
-  read_instant_warp_filter(config, parsed, "instant_warp_auto_jump", this->instant_warp_auto_jump,
-                           this->instant_warp_auto_jump_all, DCU::instant_warp_auto_jump, write_config);
-  read_instant_warp_filter(config, parsed, "instant_warp_auto_warp", this->instant_warp_auto_warp,
-                           this->instant_warp_auto_warp_all, DCU::instant_warp_auto_warp, write_config);
-  read_instant_warp_filter(config, parsed, "instant_warp_always_ask", this->instant_warp_always_ask,
-                           this->instant_warp_always_ask_all, DCU::instant_warp_always_ask, write_config);
-
-  {
-    bool unused_match_all = false;
-    read_instant_warp_filter(config, parsed, "pinned_ships", this->pinned_ships, unused_match_all, DCU::pinned_ships,
-                             write_config);
-  }
-
-  this->double_click_to_assign_ship = get_config_or_default(config, parsed, "ui", "double_click_to_assign_ship",
-                                                            DCU::double_click_to_assign_ship, write_config);
-  this->focus_search = get_config_or_default(config, parsed, "ui", "focus_search", DCU::focus_search, write_config);
-  this->format_cargo_values = get_config_or_default_with_alias(
-      config, parsed, "ui", "format_cargo_values", "cargo_format", DCU::format_cargo_values, write_config);
-  this->officer_sort = get_config_or_default(config, parsed, "ui", "officer_sort", DCU::officer_sort, write_config);
-  this->reverse_haven_history = get_config_or_default(config, parsed, "ui", "reverse_haven_history",
-                                                       DCU::reverse_haven_history, write_config);
-
-  this->dock_syncmanagement =
-      get_config_or_default(config, parsed, "ui", "dock_syncmanagement",
-                            DCU::dock_syncmanagement, write_config);
-  this->arrow_keys_to_select_ship = get_config_or_default(config, parsed, "ui", "arrow_keys_to_select_ship",
-                                                          DCU::arrow_keys_to_select_ship, write_config);
-
-  this->auto_confirm_ft_upgrade =
-      get_config_or_default(config, parsed, "ui", "auto_confirm_ft_upgrade",
-                                                        DCU::auto_confirm_ft_upgrade, write_config);
-  this->forbidden_tech_ship_name = get_config_or_default(
-      config, parsed, "ui", "forbidden_tech_ship_name", DCU::forbidden_tech_ship_name, write_config);
-  this->auto_confirm_reveal_ability =
-      get_config_or_default(config, parsed, "ui", "auto_confirm_reveal_ability",
-                                                        DCU::auto_confirm_reveal_ability, write_config);
-  this->auto_confirm_alliance_contribution =
-      get_config_or_default(config, parsed, "ui", "auto_confirm_alliance_contribution",
-                            DCU::auto_confirm_alliance_contribution, write_config);
-
-  this->extend_chest_purchase_max = get_config_or_default(config, parsed, "ui", "extend_chest_purchase_max",
-                                                          DCU::extend_chest_purchase_max, write_config);
-  this->extend_donation_slider =
-      get_config_or_default(config, parsed, "ui", "extend_donation_slider", DCU::extend_donation_slider, write_config);
-  this->extend_donation_max =
-      get_config_or_default(config, parsed, "ui", "extend_donation_max", DCU::extend_donation_max, write_config);
-
-  this->default_chat_width =
-      get_config_or_default(config, parsed, "ui", "default_chat_width", DCU::default_chat_width, write_config);
-  this->auto_open_chat =
-      get_config_or_default(config, parsed, "ui", "auto_open_chat", DCU::auto_open_chat, write_config);
-  this->disable_galaxy_chat =
-      get_config_or_default(config, parsed, "ui", "disable_galaxy_chat", DCU::disable_galaxy_chat, write_config);
-  this->disable_veil_chat =
-      get_config_or_default(config, parsed, "ui", "disable_veil_chat", DCU::disable_veil_chat, write_config);
-  this->show_player_title =
-      get_config_or_default(config, parsed, "ui", "show_player_title", DCU::show_player_title, write_config);
-  this->show_cargo_default =
-      get_config_or_default(config, parsed, "ui", "show_cargo_default", DCU::show_cargo_default, write_config);
-  this->show_player_cargo =
-      get_config_or_default(config, parsed, "ui", "show_player_cargo", DCU::show_player_cargo, write_config);
-  this->show_station_cargo =
-      get_config_or_default(config, parsed, "ui", "show_station_cargo", DCU::show_station_cargo, write_config);
-  this->show_hostile_cargo =
-      get_config_or_default(config, parsed, "ui", "show_hostile_cargo", DCU::show_hostile_cargo, write_config);
-  this->show_armada_cargo =
-      get_config_or_default(config, parsed, "ui", "show_armada_cargo", DCU::show_armada_cargo, write_config);
-
-  this->instant_cargo_counter =
-      get_config_or_default(config, parsed, "ui", "instant_cargo_counter", DCU::instant_cargo_counter, write_config);
-  this->cargo_significant_decimals =
-      get_config_or_default(config, parsed, "ui", "cargo_significant_decimals", DCU::cargo_significant_decimals, write_config);
-
-  this->always_skip_reveal_sequence = get_config_or_default(config, parsed, "ui", "always_skip_reveal_sequence",
-                                                            DCU::always_skip_reveal_sequence, write_config);
-  this->mission_hud_buttons.clear();
-  this->mission_hud_buttons.emplace(
-      "q_trials", get_mission_hud_visibility(config, parsed, "hud_q_trials", DCU::hud_q_trials, write_config));
-  this->mission_hud_buttons.emplace(
-      "field_training", get_mission_hud_visibility(config, parsed, "hud_field_training", DCU::hud_field_training,
-                                                     write_config));
-  this->mission_hud_buttons.emplace(
-      "outposts", get_mission_hud_visibility(config, parsed, "hud_outposts", DCU::hud_outposts, write_config));
-  this->mission_hud_buttons.emplace(
-      "missions", get_mission_hud_visibility(config, parsed, "hud_missions", DCU::hud_missions, write_config));
-  this->disable_exchange_all = get_config_or_default_with_alias(
-      config, parsed, "ui", "disable_exchange_all", "hide_artifact_exchange_all", DCU::disable_exchange_all, write_config);
-
-  spdlog::debug("");
-
-  this->sync_debug   = get_config_or_default(config, parsed, "sync", "debug", DCS::debug, write_config);
-  this->sync_logging = get_config_or_default(config, parsed, "sync", "logging", DCS::logging, write_config);
-  this->sync_resolver_cache_ttl =
-      get_config_or_default(config, parsed, "sync", "resolver_cache_ttl", DCS::resolver_cache_ttl, write_config);
 
+  auto& u = ui;
+  r.Read("ui", "disable_escape_exit", u.disable_escape_exit);
+  r.Read("ui", "disable_escape_exit_timer", u.disable_escape_exit_timer);
+  r.Read("ui", "disable_preview_locate", u.disable_preview_locate);
+  r.Read("ui", "disable_preview_recall", u.disable_preview_recall);
+  r.Read("ui", "disable_first_popup", u.disable_first_popup);
+  r.Read("ui", "only_show_first_popup", u.only_show_first_popup);
+  r.Read("ui", "disable_move_keys", u.disable_move_keys);
+  r.Read("ui", "disable_toast_banners", u.disable_toast_banners);
+  r.Read("ui", "default_chat_width", u.default_chat_width);
+  r.Read("ui", "auto_open_chat", u.auto_open_chat);
+  r.Read("ui", "disable_galaxy_chat", u.disable_galaxy_chat);
+  r.Read("ui", "disable_veil_chat", u.disable_veil_chat);
+  r.Read("ui", "auto_open_bulk_claim_flyout", u.auto_open_bulk_claim_flyout);
+  u.daily_bulk_claim_factions = ReadFactions(r);
+  r.Read("ui", "daily_bulk_claim_toggle_default_on", u.daily_bulk_claim_toggle_default_on);
+  r.Choose("ui", "auto_confirm_instant_warp", u.auto_confirm_instant_warp, kInstantWarp);
+  u.instant_warp_auto_jump  = ReadShipFilter(r, "instant_warp_auto_jump");
+  u.instant_warp_auto_warp  = ReadShipFilter(r, "instant_warp_auto_warp");
+  u.instant_warp_always_ask = ReadShipFilter(r, "instant_warp_always_ask");
+  // "*" pins nothing.
+  u.pinned_ships = ReadShipFilter(r, "pinned_ships").names;
+  r.Read("ui", "double_click_to_assign_ship", u.double_click_to_assign_ship);
+  r.Read("ui", "focus_search", u.focus_search);
+  r.ReadRenamed("ui", "format_cargo_values", "cargo_format", u.format_cargo_values);
+  r.Read("ui", "officer_sort", u.officer_sort);
+  r.Read("ui", "reverse_haven_history", u.reverse_haven_history);
+  r.Read("ui", "arrow_keys_to_select_ship", u.arrow_keys_to_select_ship);
+  r.Read("ui", "auto_confirm_ft_upgrade", u.auto_confirm_ft_upgrade);
+  r.Read("ui", "forbidden_tech_ship_name", u.forbidden_tech_ship_name);
+  r.Read("ui", "auto_confirm_alliance_contribution", u.auto_confirm_alliance_contribution);
+  r.Read("ui", "extend_chest_purchase_max", u.extend_chest_purchase_max);
+  r.Read("ui", "extend_donation_slider", u.extend_donation_slider);
+  r.Read("ui", "extend_donation_max", u.extend_donation_max);
+  r.Read("ui", "show_cargo_default", u.show_cargo_default);
+  r.Read("ui", "show_player_cargo", u.show_player_cargo);
+  r.Read("ui", "show_station_cargo", u.show_station_cargo);
+  r.Read("ui", "show_hostile_cargo", u.show_hostile_cargo);
+  r.Read("ui", "show_armada_cargo", u.show_armada_cargo);
+  r.Read("ui", "instant_cargo_counter", u.instant_cargo_counter);
+  r.Read("ui", "cargo_significant_decimals", u.cargo_significant_decimals);
+  r.Read("ui", "always_skip_reveal_sequence", u.always_skip_reveal_sequence);
+  r.ReadRenamed("ui", "disable_exchange_all", "hide_artifact_exchange_all", u.disable_exchange_all);
+  for (const char* button : {"q_trials", "field_training", "outposts", "daily_goals", "missions"})
+    r.Choose("ui", std::string("hud_") + button, u.mission_hud_buttons[button], kHudVisibility);
+  u.disabled_banner_types = ReadBannerTypes(r, "disabled_banner_types");
+  u.notify_banner_types   = ReadBannerTypes(r, "notify_banner_types");
+
+  r.Read("sync", "debug", sync.debug);
+  r.Read("sync", "logging", sync.logging);
+  r.Read("sync", "resolver_cache_ttl", sync.resolver_cache_ttl);
   SyncConfig sync_defaults;
-  sync_defaults.proxy      = get_config_or_default<std::string>(config, parsed, "sync", "proxy", DCS::proxy, write_log);
-  sync_defaults.verify_ssl = get_config_or_default(config, parsed, "sync", "verify_ssl", DCS::verify_ssl, write_config);
-
-  for (const auto& opt : SyncOptions) {
-    if (opt.type == SyncConfig::Type::Officer) {
-      sync_defaults.*opt.option = get_config_or_default_with_alias(
-          config, parsed, "sync", opt.option_str, "officer", false, write_config);
-    } else {
-      sync_defaults.*opt.option = get_config_or_default(config, parsed, "sync", opt.option_str, false, write_config);
-    }
-  }
-
-  spdlog::debug("");
-
-  toml::table default_targets{
-      {"stfcdata", toml::table{{"token", ""}, {"url", DCS::stfcdata_url}}},
-      {"nextspocksclub", toml::table{{"token", ""}, {"url", DCS::nextspocksclub_url}}},
-      {"spocksclub", toml::table{{"token", ""}, {"url", DCS::spocksclub_url}}},
-  };
-  parsed["sync"].as_table()->emplace<toml::table>("targets", std::move(default_targets));
-
-  read_sync_targets(config, parsed, this->sync_targets, sync_defaults);
-
-  if (auto sync_file = config["sync"]["file"].value<std::string>();
-      sync_file.has_value() && !sync_file.value().empty()) {
+  r.Read("sync", "proxy", sync_defaults.proxy);
+  r.Read("sync", "verify_ssl", sync_defaults.verify_ssl);
+  for (const auto& option : SyncOptions)
+    if (OldName(option).empty())
+      r.Read("sync", option.option_str, sync_defaults.*option.option);
+    else
+      r.ReadRenamed("sync", option.option_str, OldName(option), sync_defaults.*option.option);
+  ReadSyncTargets(r, sync.targets, sync_defaults);
+
+  if (auto sync_file = config["sync"]["file"].value<std::string>(); sync_file && !sync_file->empty()) {
     spdlog::error("Deprecation Notice: The 'sync_file' config option has been deprecated and removed. "
                   "For capturing sync output, please use a local HTTP server instead.");
   }
 
-  // set global sync options to what's actually used in targets
-  const auto targets_view = this->sync_targets | std::views::values;
-
-  this->sync_options.proxy      = sync_defaults.proxy;
-  this->sync_options.verify_ssl = sync_defaults.verify_ssl;
-
-  for (const auto& opt : SyncOptions) {
-    this->sync_options.*opt.option =
-        std::ranges::any_of(targets_view, [opt](const auto& target) { return target.*opt.option; });
-  }
-
-  spdlog::debug("");
-
-  // must explicitly include std::string typing here, or we get back char * which fails us!
-  auto disabled_banner_types_str = get_config_or_default<std::string>(config, parsed, "ui", "disabled_banner_types",
-                                                                      DCU::disabled_banner_types, write_log);
-
-  this->config_settings_url =
-      get_config_or_default<std::string>(config, parsed, "config", "settings_url", DCSC::settings_url, write_log);
-  this->config_assets_url_override = get_config_or_default<std::string>(config, parsed, "config", "assets_url_override",
-                                                                        DCSC::assets_url_override, write_log);
-
-  // Loading Screen / Transition Screen settings
-  this->loader_enabled =
-      get_config_or_default(config, parsed, "graphics", "loader_enabled", DCG::loader_enabled, write_log);
-  this->loader_transition =
-      get_config_or_default(config, parsed, "graphics", "loader_transition", DCG::loader_transition, write_log);
-  this->loader_transition_black =
-      get_config_or_default(config, parsed, "graphics", "loader_transition_black", DCG::loader_transition_black, write_log);
-  // If transition customization is disabled, force black mode (game's default background)
-  if (!this->loader_transition)
-    this->loader_transition_black = true;
-#ifdef _USE_ORIGINAL_BG
-  this->loader_transition_black = true;
-#endif
-  this->loader_image =
-      get_config_or_default<std::string>(config, parsed, "graphics", "loader_image", DCG::loader_image, write_log);
-  this->loader_logo_scale =
-      get_config_or_default(config, parsed, "graphics", "loader_logo_scale", DCG::loader_logo_scale, write_log);
-  this->galactic_anomaly_timer =
-      get_config_or_default(config, parsed, "graphics", "galactic_anomaly_timer", DCG::galactic_anomaly_timer, write_log);
-  this->loader_tip_enabled =
-      get_config_or_default(config, parsed, "graphics", "loader_tip_enabled", DCG::loader_tip_enabled, write_log);
-
-  std::vector<std::string> types = StrSplit(disabled_banner_types_str, ',');
-
-  spdlog::debug("");
-
-  std::string       bannerString;
-  std::stringstream message;
-  message << "Parsing banner strings";
-
-  spdlog::debug(message.str());
-
-  for (const auto& [key, value] : bannerTypes) {
-    auto upper_key = AsciiStrToUpper(key);
-
-    for (const std::string_view _type : types) {
-      auto stripped_type = StripLeadingAsciiWhitespace(_type);
-      auto upper_type    = AsciiStrToUpper(stripped_type);
-
-      if ("ALL" == upper_type || upper_key == upper_type) {
-        this->disabled_banner_types.emplace_back(value);
-        if (!bannerString.empty()) {
-          bannerString.append(", ");
-        }
-        bannerString.append(key);
-      }
-    }
-  }
-
-  message.str("");
-  message << "Final disabledbanner types: " << bannerString;
-  spdlog::debug(message.str());
-
-  parsed["ui"].as_table()->insert_or_assign("disabled_banner_types", bannerString);
-
-  // Parse notify_banner_types using the same bannerTypes lookup table
-  auto notify_banner_types_str = get_config_or_default<std::string>(config, parsed, "ui", "notify_banner_types",
-                                                                    DCU::notify_banner_types, write_log);
-
-  std::vector<std::string> notify_types = StrSplit(notify_banner_types_str, ',');
-  std::string              notifyString;
-
-  for (const auto& [key, value] : bannerTypes) {
-    auto upper_key = AsciiStrToUpper(key);
-    for (const std::string_view _type : notify_types) {
-      auto stripped_type = StripLeadingAsciiWhitespace(_type);
-      auto upper_type    = AsciiStrToUpper(stripped_type);
-      spdlog::warn("TEMP: Notify {} == {}", upper_type, upper_key);
-      if ("ALL" == upper_type || upper_key == upper_type) {
-        this->notify_banner_types.emplace_back(value);
-        if (!notifyString.empty())
-          notifyString.append(", ");
-        notifyString.append(key);
-      }
-    }
-  }
-
-  spdlog::debug("Final notify banner types: {}", notifyString);
-  parsed["ui"].as_table()->insert_or_assign("notify_banner_types", notifyString);
-
-  spdlog::debug("");
-
-  parse_config_shortcut(config, parsed, "move_up", GameFunction::MoveUp, DCSH::move_up);
-  parse_config_shortcut(config, parsed, "move_down", GameFunction::MoveDown, DCSH::move_down);
-  parse_config_shortcut(config, parsed, "move_left", GameFunction::MoveLeft, DCSH::move_left);
-  parse_config_shortcut(config, parsed, "move_right", GameFunction::MoveRight, DCSH::move_right);
-
-  parse_config_shortcut_aliases(config, parsed, "set_hotkeys_disabled", GameFunction::DisableHotKeys,
-                                DCSH::set_hotkeys_disabled, {"set_hotkeys_disble", "set_hotkeys_disable"});
-  parse_config_shortcut_aliases(config, parsed, "set_hotkeys_enabled", GameFunction::EnableHotKeys,
-                                DCSH::set_hotkeys_enabled, {"set_hotkeys_enable"});
-
-  parse_config_shortcut(config, parsed, "select_chatalliance", GameFunction::SelectChatAlliance,
-                        DCSH::select_chatalliance);
-  parse_config_shortcut(config, parsed, "select_chatglobal", GameFunction::SelectChatGlobal, DCSH::select_chatglobal);
-  parse_config_shortcut(config, parsed, "select_chatprivate", GameFunction::SelectChatPrivate,
-                        DCSH::select_chatprivate);
-  parse_config_shortcut(config, parsed, "quit", GameFunction::Quit, DCSH::quit);
-
-  parse_config_shortcut(config, parsed, "select_ship1", GameFunction::SelectShip1, DCSH::select_ship1);
-  parse_config_shortcut(config, parsed, "select_ship2", GameFunction::SelectShip2, DCSH::select_ship2);
-  parse_config_shortcut(config, parsed, "select_ship3", GameFunction::SelectShip3, DCSH::select_ship3);
-  parse_config_shortcut(config, parsed, "select_ship4", GameFunction::SelectShip4, DCSH::select_ship4);
-  parse_config_shortcut(config, parsed, "select_ship5", GameFunction::SelectShip5, DCSH::select_ship5);
-  parse_config_shortcut(config, parsed, "select_ship6", GameFunction::SelectShip6, DCSH::select_ship6);
-  parse_config_shortcut(config, parsed, "select_ship7", GameFunction::SelectShip7, DCSH::select_ship7);
-  parse_config_shortcut(config, parsed, "select_ship8", GameFunction::SelectShip8, DCSH::select_ship8);
-  parse_config_shortcut(config, parsed, "select_current", GameFunction::SelectCurrent, DCSH::select_current);
-  parse_config_shortcut(config, parsed, "focus_search", GameFunction::FocusSearch, DCSH::focus_search);
-
-  parse_config_shortcut(config, parsed, "action_primary", GameFunction::ActionPrimary, DCSH::action_primary);
-  parse_config_shortcut(config, parsed, "action_secondary", GameFunction::ActionSecondary, DCSH::action_secondary);
-  parse_config_shortcut(config, parsed, "action_queue", GameFunction::ActionQueue, DCSH::action_queue);
-  parse_config_shortcut(config, parsed, "action_queue_clear", GameFunction::ActionQueueClear, DCSH::action_queue_clear);
-  parse_config_shortcut(config, parsed, "action_view", GameFunction::ActionView, DCSH::action_view);
-  parse_config_shortcut(config, parsed, "action_recall", GameFunction::ActionRecall, DCSH::action_recall);
-  parse_config_shortcut(config, parsed, "action_recall_cancel", GameFunction::ActionRecallCancel,
-                        DCSH::action_recall_cancel);
-  parse_config_shortcut(config, parsed, "action_repair", GameFunction::ActionRepair, DCSH::action_repair);
-  parse_config_shortcut(config, parsed, "show_chat", GameFunction::ShowChat, DCSH::show_chat);
-  parse_config_shortcut(config, parsed, "show_chatside1", GameFunction::ShowChatSide1, DCSH::show_chatside1);
-  parse_config_shortcut(config, parsed, "show_chatside2", GameFunction::ShowChatSide2, DCSH::show_chatside2);
-  parse_config_shortcut(config, parsed, "show_galaxy", GameFunction::ShowGalaxy, DCSH::show_galaxy);
-  parse_config_shortcut_aliases(config, parsed, "show_galaxy_native", GameFunction::NativeShortcutGalaxy,
-                                DCSH::show_galaxy_native, {"native_shortcut_galaxy"});
-  parse_config_shortcut(config, parsed, "show_system", GameFunction::ShowSystem, DCSH::show_system);
-  parse_config_shortcut(config, parsed, "zoom_preset1", GameFunction::ZoomPreset1, DCSH::zoom_preset1);
-  parse_config_shortcut(config, parsed, "zoom_preset2", GameFunction::ZoomPreset2, DCSH::zoom_preset2);
-  parse_config_shortcut(config, parsed, "zoom_preset3", GameFunction::ZoomPreset3, DCSH::zoom_preset3);
-  parse_config_shortcut(config, parsed, "zoom_preset4", GameFunction::ZoomPreset4, DCSH::zoom_preset4);
-  parse_config_shortcut(config, parsed, "zoom_preset5", GameFunction::ZoomPreset5, DCSH::zoom_preset5);
-  parse_config_shortcut(config, parsed, "zoom_in", GameFunction::ZoomIn, DCSH::zoom_in);
-  parse_config_shortcut(config, parsed, "zoom_out", GameFunction::ZoomOut, DCSH::zoom_out);
-  parse_config_shortcut(config, parsed, "zoom_max", GameFunction::ZoomMax, DCSH::zoom_max);
-  parse_config_shortcut(config, parsed, "zoom_min", GameFunction::ZoomMin, DCSH::zoom_min);
-  parse_config_shortcut(config, parsed, "zoom_reset", GameFunction::ZoomReset, DCSH::zoom_reset);
-  parse_config_shortcut(config, parsed, "ui_scaleup", GameFunction::UiScaleUp, DCSH::ui_scaleup);
-  parse_config_shortcut(config, parsed, "ui_scaledown", GameFunction::UiScaleDown, DCSH::ui_scaledown);
-  parse_config_shortcut(config, parsed, "ui_scaleshipup", GameFunction::UiShipScaleUp, DCSH::ui_scaleshipup);
-  parse_config_shortcut(config, parsed, "ui_scaleshipdown", GameFunction::UiShipScaleDown, DCSH::ui_scaleshipdown);
-  parse_config_shortcut(config, parsed, "ui_scaleviewerup", GameFunction::UiViewerScaleUp, DCSH::ui_scaleviewerup);
-  parse_config_shortcut(config, parsed, "ui_scaleviewerdown", GameFunction::UiViewerScaleDown,
-                        DCSH::ui_scaleviewerdown);
-
-  parse_config_shortcut(config, parsed, "log_debug", GameFunction::LogLevelDebug, DCSH::log_debug);
-  parse_config_shortcut(config, parsed, "log_trace", GameFunction::LogLevelTrace, DCSH::log_trace);
-  parse_config_shortcut(config, parsed, "log_info", GameFunction::LogLevelInfo, DCSH::log_info);
-  parse_config_shortcut(config, parsed, "log_warn", GameFunction::LogLevelWarn, DCSH::log_warn);
-  parse_config_shortcut(config, parsed, "log_error", GameFunction::LogLevelError, DCSH::log_error);
-  parse_config_shortcut(config, parsed, "log_off", GameFunction::LogLevelOff, DCSH::log_off);
-  parse_config_shortcut(config, parsed, "restart", GameFunction::Restart, DCSH::restart);
-
-  parse_config_shortcut(config, parsed, "show_awayteam", GameFunction::ShowAwayTeam, DCSH::show_awayteam);
-  parse_config_shortcut(config, parsed, "show_gifts", GameFunction::ShowGifts, DCSH::show_gifts);
-  parse_config_shortcut(config, parsed, "show_artifacts", GameFunction::ShowArtifacts, DCSH::show_artifacts);
-  parse_config_shortcut(config, parsed, "show_commander", GameFunction::ShowCommander, DCSH::show_commander);
-  parse_config_shortcut(config, parsed, "show_daily", GameFunction::ShowDaily, DCSH::show_daily);
-  parse_config_shortcut(config, parsed, "show_events", GameFunction::ShowEvents, DCSH::show_events);
-  parse_config_shortcut_aliases(config, parsed, "show_events_native", GameFunction::NativeShortcutEvents,
-                                DCSH::show_events_native, {"native_shortcut_events"});
-  parse_config_shortcut(config, parsed, "show_exocomp", GameFunction::ShowExoComp, DCSH::show_exocomp);
-  parse_config_shortcut(config, parsed, "show_factions", GameFunction::ShowFactions, DCSH::show_factions);
-  parse_config_shortcut(config, parsed, "show_inventory", GameFunction::ShowInventory, DCSH::show_inventory);
-  parse_config_shortcut(config, parsed, "show_missions", GameFunction::ShowMissions, DCSH::show_missions);
-  parse_config_shortcut(config, parsed, "show_research", GameFunction::ShowResearch, DCSH::show_research);
-  parse_config_shortcut(config, parsed, "show_scrapyard", GameFunction::ShowScrapYard, DCSH::show_scrapyard);
-  parse_config_shortcut(config, parsed, "show_settings", GameFunction::ShowSettings, DCSH::show_settings);
-  parse_config_shortcut(config, parsed, "toggle_shortcut_hints", GameFunction::ToggleShortcutHints,
-                        DCSH::toggle_shortcut_hints);
-  parse_config_shortcut(config, parsed, "show_officers", GameFunction::ShowOfficers, DCSH::show_officers);
-  parse_config_shortcut(config, parsed, "show_officerpresets", GameFunction::ShowOfficerPresets,
-                        DCSH::show_officerpresets);
-  parse_config_shortcut(config, parsed, "show_officerswap", GameFunction::ShowOfficerSwap, DCSH::show_officerswap);
-  parse_config_shortcut(config, parsed, "show_qtrials", GameFunction::ShowQTrials, DCSH::show_qtrials);
-  parse_config_shortcut(config, parsed, "show_refinery", GameFunction::ShowRefinery, DCSH::show_refinery);
-  parse_config_shortcut(config, parsed, "show_ships", GameFunction::ShowShips, DCSH::show_ships);
-  parse_config_shortcut(config, parsed, "show_shipconstruction", GameFunction::ShowShipConstruction,
-                        DCSH::show_shipconstruction);
-  parse_config_shortcut(config, parsed, "show_shipswap", GameFunction::ShowShipSwap, DCSH::show_shipswap);
-  parse_config_shortcut(config, parsed, "show_shields", GameFunction::ShowShields, DCSH::show_shields);
-  parse_config_shortcut(config, parsed, "show_battlelogs", GameFunction::ShowBattlelogs, DCSH::show_battlelogs);
-  parse_config_shortcut(config, parsed, "show_stationexterior", GameFunction::ShoWStationExterior,
-                        DCSH::show_stationexterior);
-  parse_config_shortcut(config, parsed, "show_stationinterior", GameFunction::ShowStationInterior,
-                        DCSH::show_stationinterior);
-  parse_config_shortcut(config, parsed, "show_haven", GameFunction::ShowHaven, DCSH::show_haven);
-  parse_config_shortcut(config, parsed, "toggle_queue", GameFunction::ToggleQueue, DCSH::toggle_queue);
-  parse_config_shortcut(config, parsed, "toggle_instant_warp", GameFunction::ToggleAutoConfirmInstantWarp,
-                        DCSH::toggle_instant_warp);
-
-  if (this->hotkeys_extended) {
-    parse_config_shortcut(config, parsed, "show_alliance", GameFunction::ShowAlliance, DCSH::show_alliance);
-
-    if (this->enable_experimental) {
-      parse_config_shortcut(config, parsed, "show_alliance_help", GameFunction::ShowAllianceHelp,
-                            DCSH::show_alliance_help);
-      parse_config_shortcut(config, parsed, "show_alliance_armada", GameFunction::ShowAllianceArmada,
-                            DCSH::show_alliance_armada);
-    }
-
-    parse_config_shortcut(config, parsed, "show_bookmarks", GameFunction::ShowBookmarks, DCSH::show_bookmarks);
-
-    if (this->enable_experimental) {
-      parse_config_shortcut(config, parsed, "show_lookup", GameFunction::ShowLookup, DCSH::show_lookup);
-    }
-
-    parse_config_shortcut(config, parsed, "set_zoom_preset1", GameFunction::SetZoomPreset1, DCSH::set_zoom_preset1);
-    parse_config_shortcut(config, parsed, "set_zoom_preset2", GameFunction::SetZoomPreset2, DCSH::set_zoom_preset2);
-    parse_config_shortcut(config, parsed, "set_zoom_preset3", GameFunction::SetZoomPreset3, DCSH::set_zoom_preset3);
-    parse_config_shortcut(config, parsed, "set_zoom_preset4", GameFunction::SetZoomPreset4, DCSH::set_zoom_preset4);
-    parse_config_shortcut(config, parsed, "set_zoom_preset5", GameFunction::SetZoomPreset5, DCSH::set_zoom_preset5);
-    parse_config_shortcut(config, parsed, "set_zoom_default", GameFunction::SetZoomDefault, DCSH::set_zoom_default);
-    parse_config_shortcut(config, parsed, "toggle_preview_locate", GameFunction::TogglePreviewLocate,
-                          DCSH::toggle_preview_locate);
-    parse_config_shortcut(config, parsed, "toggle_preview_recall", GameFunction::TogglePreviewRecall,
-                          DCSH::toggle_preview_recall);
-    parse_config_shortcut(config, parsed, "toggle_cargo_default", GameFunction::ToggleCargoDefault,
-                          DCSH::toggle_cargo_default);
-    parse_config_shortcut(config, parsed, "toggle_cargo_player", GameFunction::ToggleCargoPlayer,
-                          DCSH::toggle_cargo_player);
-    parse_config_shortcut(config, parsed, "toggle_cargo_station", GameFunction::ToggleCargoStation,
-                          DCSH::toggle_cargo_station);
-    parse_config_shortcut(config, parsed, "toggle_cargo_hostile", GameFunction::ToggleCargoHostile,
-                          DCSH::toggle_cargo_hostile);
-    parse_config_shortcut(config, parsed, "toggle_cargo_armada", GameFunction::ToggleCargoArmada,
-                          DCSH::toggle_cargo_armada);
-  }
-
-  spdlog::debug("");
-
-  if (!std::filesystem::exists(File::MakePath(File::Config()))) {
-    message.str("");
-    message << "Creating " << File::Config() << " (default config file)";
-    spdlog::warn(message.str());
-
-    Config::Save(parsed, File::Config(), false);
+  // The global options say whether any target wants a category, so the game hooks can skip the rest.
+  sync.options.proxy      = sync_defaults.proxy;
+  sync.options.verify_ssl = sync_defaults.verify_ssl;
+  for (const auto& option : SyncOptions) {
+    sync.options.*option.option = std::ranges::any_of(sync.targets | std::views::values,
+                                                      [&](const auto& target) { return target.*option.option; });
   }
 
-  message.str("");
-  message << "Creating " << File::Vars() << " (final config file)";
-  spdlog::info(message.str());
+  r.Read("config", "settings_url", game.settings_url);
+  r.Read("config", "assets_url_override", game.assets_url_override);
 
-  if (std::filesystem::exists(FILE_DEF_PARSED)) {
-    message.str("");
-    message << "Removing " << FILE_DEF_PARSED << " (old parsed file)";
-    spdlog::info(message.str());
+  Shortcut::Load(config, parsed, control.hotkeys_extended, control.enable_experimental);
 
-    std::filesystem::remove(FILE_DEF_PARSED);
+  if (first && !std::filesystem::exists(File::Path(File::Config()))) {
+    spdlog::warn("Creating {} (default config file)", File::Config());
+    Save(parsed, File::Config(), false);
   }
+  spdlog::info("Creating {} (final config file)", File::Vars());
+  Save(parsed, File::Vars(), true);
 
-  Config::Save(parsed, File::Vars());
-
+  if (!first)
+    return;
   std::cout << "\n\n-----------------------------\n\n"
-            << parsed << "\n\n-----------------------------\nVersion "
-
+            << parsed << "\n\n-----------------------------\n"
 #if VERSION_PATCH
             << "Loaded beta version " << VERSION_MAJOR << "." << VERSION_MINOR << "." << VERSION_REVISION << " (Patch "
-            << VERSION_PATCH << ")\n\n"
-            << "NOTE: Beta versions may have unexpected bugs and issues.\n\n"
+            << VERSION_PATCH << ")\n\nNOTE: Beta versions may have unexpected bugs and issues.\n\n";
 #else
-            << "Loaded beta version " << VERSION_MAJOR << "." << VERSION_MINOR << "." << VERSION_REVISION
-            << " (Release)"
+            << "Loaded release version " << VERSION_MAJOR << "." << VERSION_MINOR << "." << VERSION_REVISION << "\n\n";
 #endif
+}
 
-            << "\n\nPlease see https://github.com/STFC-Mod/mod for latest configuration help, examples and future "
-               "releases\n"
-            << "or visit the STFC Community Mod discord server at https://discord.gg/PrpHgs7Vjs\n\n";
+NotificationSound Config::NotificationSoundForToast(int toast_state) const
+{
+  switch (toast_state) {
+    case static_cast<int>(ToastState::Victory):
+      return audio.alert_victory;
+    case static_cast<int>(ToastState::Defeat):
+      return audio.alert_defeat;
+    case static_cast<int>(ToastState::ArmadaCreated):
+      return audio.alert_armada_created;
+    case static_cast<int>(ToastState::ArmadaBattleWon):
+      return audio.alert_armada_battle_won;
+    case static_cast<int>(ToastState::ArmadaBattleLost):
+      return audio.alert_armada_battle_lost;
+    default:
+      return NotificationSound::None;
+  }
 }
diff --git a/mods/src/config.h b/mods/src/config.h
index 91ede6a42..80944075a 100644
--- a/mods/src/config.h
+++ b/mods/src/config.h
@@ -1,42 +1,40 @@
 #pragma once
 
+#include "patches/notification_audio.h"
+
+// User settings from the settings TOML. Each struct is a TOML section and each member is named after its key,
+// with its default as the initializer: Config::Get().graphics.ui_scale is [graphics] ui_scale. They are read at
+// startup and again whenever the file changes; a few are also toggled at runtime by hotkeys. Everything runs on
+// the game thread except sync, which only reads.
+
 #include <array>
 #include <map>
 #include <string>
 #include <string_view>
 #include <vector>
 
-#include <toml++/toml.h>
-
-#include "patches/notification_audio.h"
-
-#if _WIN32
-#include <Windows.h>
-#endif
-
-class SyncConfig
-{
-public:
+// Which categories of game data are uploaded, globally ([sync]) or for one target ([sync.targets.<name>]).
+struct SyncConfig {
   enum class Type {
-    AwayAssignments,
-    Battles,
-    Buffs,
-    Buildings,
-    EmeraldChain,
-    Fleets,
-    Haven,
-    Inventory,
-    Jobs,
-    Missions,
-    Officer,
-    Profile,
-    Research,
-    Resources,
-    Ships,
-    Slots,
-    StoreOffers,
-    Tech,
-    Traits
+    kAwayAssignments,
+    kBattles,
+    kBuffs,
+    kBuildings,
+    kEmeraldChain,
+    kFleets,
+    kHaven,
+    kInventory,
+    kJobs,
+    kMissions,
+    kOfficer,
+    kProfile,
+    kResearch,
+    kResources,
+    kShips,
+    kSlots,
+    kStoreOffers,
+    kTech,
+    kTraits
   };
 
   struct Option {
@@ -47,317 +45,323 @@ class SyncConfig
   };
 
   std::string proxy;
-
-  bool verify_ssl       = true;
-  bool away_assignments = false;
-  bool battlelogs       = false;
-  bool buffs            = false;
-  bool buildings        = true;
-  bool fleets           = false;
-  bool haven            = true;
-  bool inventory        = false;
-  bool jobs             = false;
-  bool missions         = false;
-  bool officers         = false;
-  bool profile          = false;
-  bool research         = true;
-  bool resources        = false;
-  bool ships            = false;
-  bool slots            = false;
-  bool store_offers     = false;
-  bool tech             = false;
-  bool traits           = false;
+  bool        verify_ssl       = true;
+  bool        away_assignments = false;
+  bool        battlelogs       = false;
+  bool        buffs            = false;
+  bool        buildings        = false;
+  bool        fleets           = false;
+  bool        haven            = false;
+  bool        inventory        = false;
+  bool        jobs             = false;
+  bool        missions         = false;
+  bool        officers         = false;
+  bool        profile          = false;
+  bool        research         = false;
+  bool        resources        = false;
+  bool        ships            = false;
+  bool        slots            = false;
+  bool        store_offers     = false;
+  bool        tech             = false;
+  bool        traits           = false;
 
   [[nodiscard]] bool enabled(Type type) const;
 };
 
 constexpr std::array SyncOptions{
-    SyncConfig::Option{SyncConfig::Type::AwayAssignments, "away_assignment", "away_assignments",
+    SyncConfig::Option{SyncConfig::Type::kAwayAssignments, "away_assignment", "away_assignments",
                        &SyncConfig::away_assignments},
-    SyncConfig::Option{SyncConfig::Type::Battles, "battlelog", "battlelogs", &SyncConfig::battlelogs},
-    SyncConfig::Option{SyncConfig::Type::Buffs, "buff", "buffs", &SyncConfig::buffs},
-    SyncConfig::Option{SyncConfig::Type::Buildings, "module", "buildings", &SyncConfig::buildings},
-    SyncConfig::Option{SyncConfig::Type::EmeraldChain, "emerald_chain", "buffs", &SyncConfig::buffs},
-    SyncConfig::Option{SyncConfig::Type::Fleets, "fleet", "fleets", &SyncConfig::fleets},
-    SyncConfig::Option{SyncConfig::Type::Haven, "haven", "haven", &SyncConfig::haven},
-    SyncConfig::Option{SyncConfig::Type::Inventory, "inventory", "inventory", &SyncConfig::inventory},
-    SyncConfig::Option{SyncConfig::Type::Jobs, "job", "jobs", &SyncConfig::jobs},
-    SyncConfig::Option{SyncConfig::Type::Missions, "mission", "missions", &SyncConfig::missions},
-    SyncConfig::Option{SyncConfig::Type::Officer, "officer", "officers", &SyncConfig::officers},
-    SyncConfig::Option{SyncConfig::Type::Profile, "profile", "profile", &SyncConfig::profile},
-    SyncConfig::Option{SyncConfig::Type::Research, "research", "research", &SyncConfig::research},
-    SyncConfig::Option{SyncConfig::Type::Resources, "resource", "resources", &SyncConfig::resources},
-    SyncConfig::Option{SyncConfig::Type::Ships, "ship", "ships", &SyncConfig::ships},
-    SyncConfig::Option{SyncConfig::Type::Slots, "slot", "slots", &SyncConfig::slots},
-    SyncConfig::Option{SyncConfig::Type::StoreOffers, "store_offer", "store_offers", &SyncConfig::store_offers},
-    SyncConfig::Option{SyncConfig::Type::Tech, "ft", "tech", &SyncConfig::tech},
-    SyncConfig::Option{SyncConfig::Type::Traits, "trait", "traits", &SyncConfig::traits},
+    SyncConfig::Option{SyncConfig::Type::kBattles, "battlelog", "battlelogs", &SyncConfig::battlelogs},
+    SyncConfig::Option{SyncConfig::Type::kBuffs, "buff", "buffs", &SyncConfig::buffs},
+    SyncConfig::Option{SyncConfig::Type::kBuildings, "module", "buildings", &SyncConfig::buildings},
+    SyncConfig::Option{SyncConfig::Type::kEmeraldChain, "emerald_chain", "buffs", &SyncConfig::buffs},
+    SyncConfig::Option{SyncConfig::Type::kFleets, "fleet", "fleets", &SyncConfig::fleets},
+    SyncConfig::Option{SyncConfig::Type::kHaven, "haven", "haven", &SyncConfig::haven},
+    SyncConfig::Option{SyncConfig::Type::kInventory, "inventory", "inventory", &SyncConfig::inventory},
+    SyncConfig::Option{SyncConfig::Type::kJobs, "job", "jobs", &SyncConfig::jobs},
+    SyncConfig::Option{SyncConfig::Type::kMissions, "mission", "missions", &SyncConfig::missions},
+    SyncConfig::Option{SyncConfig::Type::kOfficer, "officer", "officers", &SyncConfig::officers},
+    SyncConfig::Option{SyncConfig::Type::kProfile, "profile", "profile", &SyncConfig::profile},
+    SyncConfig::Option{SyncConfig::Type::kResearch, "research", "research", &SyncConfig::research},
+    SyncConfig::Option{SyncConfig::Type::kResources, "resource", "resources", &SyncConfig::resources},
+    SyncConfig::Option{SyncConfig::Type::kShips, "ship", "ships", &SyncConfig::ships},
+    SyncConfig::Option{SyncConfig::Type::kSlots, "slot", "slots", &SyncConfig::slots},
+    SyncConfig::Option{SyncConfig::Type::kStoreOffers, "store_offer", "store_offers", &SyncConfig::store_offers},
+    SyncConfig::Option{SyncConfig::Type::kTech, "ft", "tech", &SyncConfig::tech},
+    SyncConfig::Option{SyncConfig::Type::kTraits, "trait", "traits", &SyncConfig::traits},
 };
 
 constexpr std::string to_string(const SyncConfig::Type type)
 {
-  for (const auto& opt : SyncOptions) {
-    if (opt.type == type) {
+  for (const auto& opt : SyncOptions)
+    if (opt.type == type)
       return std::string(opt.type_str);
-    }
-  }
-
   return {};
 }
 
 constexpr std::string operator+(const std::string& prefix, const SyncConfig::Type type)
-{
-  return prefix + to_string(type);
-}
+{ return prefix + to_string(type); }
 
 constexpr std::string operator+(const SyncConfig::Type type, const std::string& suffix)
-{
-  return to_string(type) + suffix;
-}
+{ return to_string(type) + suffix; }
 
-class SyncTargetConfig : public SyncConfig
-{
-public:
+struct SyncTargetConfig : SyncConfig {
   std::string url;
   std::string token;
 };
 
 enum class MissionHudVisibility {
-  Auto,
-  Always,
-  Never,
+  kAuto,
+  kAlways,
+  kNever,
 };
 
 enum class InstantWarpConfirmation {
-  None,
-  Warp,
-  Jump,
+  kNone,
+  kWarp,
+  kJump,
 };
 
 enum class FleetLabelDetail {
-  Native,
-  Expanded,
-  Compact,
-  Threshold,
+  kNative,
+  kExpanded,
+  kCompact,
+  kThreshold,
 };
 
 struct FleetLabelProfile {
-  FleetLabelDetail detail;
-  float            zoom_threshold;
+  FleetLabelDetail detail         = FleetLabelDetail::kNative;
+  float            zoom_threshold = 0.5f;
+};
+
+// Ship names from a comma list, each split by ShipNameWords, or every ship for "*".
+struct ShipFilter {
+  std::vector<std::vector<std::string>> names;
+  bool                                  all = false;
 };
 
-// Part of UI Scale
-void ApplyUiShipScaleToLoadedShips(float old_multiplier, float new_multiplier);
+struct SettingsFile;
 
 class Config final
 {
 public:
-  Config();
-
+  [[nodiscard]] NotificationSound NotificationSoundForToast(int toast_state) const;
+  // The current settings. Call it again rather than keeping the reference: a reload replaces them.
   [[nodiscard]] static Config& Get();
-  [[nodiscard]] static float   GetDPI();
-  static float                 RefreshDPI();
-
-#ifdef _WIN32
-  [[nodiscard]] static HWND WindowHandle();
-#endif
+  // Re-reads the settings file and makes it current, rebinding shortcuts. A file that does not parse keeps the
+  // current settings. [patches] decides which hooks are installed, so its changes wait for a restart. Game thread.
+  static bool Reload();
+  // The frame tick's check: reloads once the settings file has changed and then stayed unchanged for a second.
+  static void ReloadIfChanged();
 
-  static void Save(const toml::table& config, std::string_view filename, bool apply_warning = true);
-  void        Load();
-  void        AdjustUiScale(bool scaleUp);
-  void        AdjustUiShipScale(bool scaleUp);
-  void        AdjustUiViewerScale(bool scaleUp);
-
-  [[nodiscard]] MissionHudVisibility MissionHudButtonVisibility(std::string_view button_name) const;
-  [[nodiscard]] NotificationSound    NotificationSoundForToast(int toast_state) const;
-
-  // Disallow copying/moving to enforce singleton
   Config(const Config&)            = delete;
   Config& operator=(const Config&) = delete;
-  Config(Config&&)                 = delete;
-  Config& operator=(Config&&)      = delete;
-
-  float             ui_scale;
-  float             ui_scale_step;
-  float             ui_scale_ship;
-  float             ui_scale_viewer;
-  float             zoom;
-  float             haven_zoom;
-  float             interior_zoom_scale;
-  float             fr_scale;
-  FleetLabelProfile zoom_label_player;
-  FleetLabelProfile zoom_label_non_player;
-  bool              allow_cursor;
-  bool              free_resize;
-  bool              adjust_scale_res;
-
-  bool  use_out_of_dock_power;
-  float system_pan_momentum;
-  float system_pan_momentum_falloff;
-  bool disable_target_camera_lock;
-
-  float keyboard_zoom_speed;
-  int   select_timer;
-
-  bool  queue_enabled;
-  bool  kirshara_fixes;
-  bool  hotkeys_enabled;
-  bool  hotkeys_extended;
-  bool  primary_requires_visible_target;
-  bool  use_scopely_hotkeys;
-  bool  use_presets_as_default;
-  bool  enable_experimental;
-  float default_system_zoom;
-
-  float system_zoom_preset_1;
-  float system_zoom_preset_2;
-  float system_zoom_preset_3;
-  float system_zoom_preset_4;
-  float system_zoom_preset_5;
-  float transition_time;
-
-  bool             borderless_fullscreen;
-  std::vector<int> disabled_banner_types;
-  std::vector<int> notify_banner_types;
-
-  int                      extend_chest_purchase_max;
-  int                      extend_donation_max;
-  bool                     extend_donation_slider;
-  bool                     disable_move_keys;
-  bool                     disable_preview_locate;
-  bool                     disable_preview_recall;
-  bool                     disable_escape_exit;
-  int                      disable_escape_exit_timer;
-  float                    default_chat_width;
-  bool                     auto_open_chat;
-  bool                     disable_galaxy_chat;
-  bool                     disable_veil_chat;
-  bool                     show_player_title;
-  bool                     disable_first_popup;
-  bool                     disable_toast_banners;
-  bool                     trace_audio_events;
-  bool                     disable_all_audio_events;
-  std::vector<std::string> disabled_audio_events;
-  NotificationSound alert_victory            = NotificationSound::None;
-  NotificationSound alert_defeat             = NotificationSound::None;
-  NotificationSound alert_armada_created     = NotificationSound::None;
-  NotificationSound alert_armada_battle_won  = NotificationSound::None;
-  NotificationSound alert_armada_battle_lost = NotificationSound::None;
-  bool                     auto_open_bulk_claim_flyout;
-  bool                     auto_confirm_ft_upgrade;
-  bool                     forbidden_tech_ship_name;
-  bool                     auto_confirm_reveal_ability;
-  bool                     auto_confirm_alliance_contribution;
-
-  std::vector<std::string> daily_bulk_claim_factions;
-
-  bool daily_bulk_claim_toggle_default_on;
-
-  InstantWarpConfirmation auto_confirm_instant_warp;
-
-  std::vector<std::string> instant_warp_auto_jump;
-  std::vector<std::string> instant_warp_auto_warp;
-  bool                     instant_warp_auto_jump_all = false;
-  bool                     instant_warp_auto_warp_all = false;
-
-  std::vector<std::string> instant_warp_always_ask;
-  bool                     instant_warp_always_ask_all = false;
-
-  std::vector<std::string> pinned_ships;
-
-  bool double_click_to_assign_ship;
-  bool focus_search;
-  bool format_cargo_values;
-  bool officer_sort;
-  bool reverse_haven_history;
-  bool arrow_keys_to_select_ship;
-  bool dock_syncmanagement;
-
-  bool only_show_first_popup;
-
-  bool show_cargo_default;
-  bool show_player_cargo;
-  bool show_station_cargo;
-  bool show_hostile_cargo;
-  bool show_armada_cargo;
-  bool instant_cargo_counter;
-
-  bool                                        always_skip_reveal_sequence;
-  std::map<std::string, MissionHudVisibility> mission_hud_buttons;
-
-  bool       sync_logging;
-  bool       sync_debug;
-  int        sync_resolver_cache_ttl;
-  SyncConfig sync_options;
-
-  std::map<std::string, SyncTargetConfig> sync_targets;
-
-  bool installUiScaleHooks;
-  bool installZoomHooks;
-  bool installHavenZoomHooks;
-  bool installInteriorZoomHooks;
-  bool installBuffFixHooks;
-  bool installToastBannerHooks;
-  bool installPanHooks;
-  bool installHotkeyHooks;
-  bool installFreeResizeHooks;
-  bool installTempCrashFixes;
-  bool installTestPatches;
-  bool installMiscPatches;
-  bool installMissionHudTweaksHooks;
-  bool disable_exchange_all;
-  bool installChatPatches;
-  bool installPlayerTitleDisplayHooks;
-  bool installSyncPatches;
-  bool installGameVersionHook;
-  bool installObjectTracker;
-  bool installGiftsBulkClaimHooks;
-  bool installDailyFactionBulkClaimHooks;
-  bool installGalacticAnomalyTimerHooks;
-  bool installLoadingTipHooks;
-  bool installDoubleClickAssignShipHooks;
-  bool installForbiddenTechConfirmationHooks;
-  bool installForbiddenTechShipNameHooks;
-  bool installRevealConfirmationHooks;
-  bool installInstantWarpConfirmationHooks;
-  bool installAudioEventHooks;
-  bool installActionQueueRecoveryHooks;
-  bool installQueueAddressGuardHooks;
-  bool installThinQueueProtectionHooks;
-  bool installArtifactExchangeHooks;
-
-  std::string config_settings_url;
-  std::string config_assets_url_override;
-
-  // Loading Screen / Transition Screen
-  bool        loader_enabled;
-  bool        loader_transition;
-  bool        loader_transition_black;
-  std::string loader_image;
-  float       loader_logo_scale;
-  bool        loader_tip_enabled;
-  bool        galactic_anomaly_timer;
-
-  bool installLoadingScreenHooks;
-  bool installTransitionScreenHooks;
-
-  // Cargo formatting
-  bool installCargoFormatHooks;
-  bool installInstantCargoCounterHooks;
-  int  cargo_significant_decimals;
-
-  // Officer roster/assignment "Below Deck Ability" sort option restore
-  bool installOfficerSortHooks;
-
-  // Fleet management dock ship sort: pin configured ships to the front
-  bool installPinnedShipSortHooks;
-
-  // Fleet management dock: SHIFT+click a ship tile to pin/unpin it
-  bool installPinnedShipClickToggle;
-
-  // Haven help-history list ordering
-  bool installHavenHistoryHooks;
-
-  // Native Alliance Games store research, currency and purchase refresh
-  bool installAllianceGamesStoreHooks;
+
+  // Hook groups. Users switch these off when another mod (such as a BepInEx plugin) hooks the same methods.
+  struct Patches {
+    bool pinnedshipclicktoggle      = true;
+    bool thinqueueprotectionhooks   = true;
+    bool queueaddressguardhooks     = true;
+    bool actionqueuerecoveryhooks   = true;
+    bool revealconfirmhooks         = true;
+    bool chattitledisplayhooks      = true;
+    bool interiorzoomhooks          = true;
+    bool uiscalehooks               = true;
+    bool zoomhooks                  = true;
+    bool havenzoomhooks             = true;
+    bool havenhistoryhooks          = true;
+    bool alliancegamesstorehooks    = true;
+    bool bufffixhooks               = true;
+    bool toastbannerhooks           = true;
+    bool panhooks                   = true;
+    bool hotkeyhooks                = true;
+    bool freeresizehooks            = true;
+    bool tempcrashfixes             = true;
+    bool testpatches                = true;
+    bool miscpatches                = true;
+    bool missionhudtweakshooks      = true;
+    bool chatpatches                = true;
+    bool syncpatches                = true;
+    bool game_version               = true;
+    bool objecttracker              = true;
+    bool loadingscreenhooks         = true;
+    bool transitionscreenhooks      = true;
+    bool giftsbulkclaimhooks        = true;
+    bool dailyfactionbulkclaimhooks = true;
+    bool galacticanomalytimerhooks  = true;
+    bool loadingtiphooks            = true;
+    bool doubleclickassignshiphooks = true;
+    bool forbiddentechconfirmhooks  = true;
+    bool forbiddentechshipnamehooks = true;
+    bool audioeventhooks            = true;
+    bool instantcargocounterhooks   = true;
+    bool cargoformathooks           = true;
+    bool officersorthooks           = true;
+    bool pinnedshiphooks            = true;
+    bool artifactexchangehooks      = true;
+
+    bool operator==(const Patches&) const = default;
+  } patches;
+
+  struct Control {
+    bool primary_requires_visible_target = false;
+    bool kirshara_fixes                  = true;
+    bool queue_enabled                   = true;
+    bool hotkeys_enabled                 = true;
+    bool hotkeys_extended                = true;
+    bool use_scopely_hotkeys             = false;
+    // Milliseconds within which pressing a ship's number again flies the camera to it.
+    int  select_timer        = 500;
+    bool enable_experimental = false;
+  } control;
+
+  struct Graphics {
+    float interior_zoom_scale = 2.0f;
+    float ui_scale            = 0.6f;
+    float ui_scale_step       = 0.05f;
+    float ui_scale_ship       = 1.0f;
+    float ui_scale_viewer     = 1.2f;
+    // The farthest system zoom; presets and zoom shortcuts are in the same unit.
+    float             zoom       = 5000.0f;
+    float             haven_zoom = 4000.0f;
+    float             fr_scale   = 2.0f;
+    FleetLabelProfile zoom_label_player;
+    FleetLabelProfile zoom_label_non_player;
+    bool              free_resize         = true;
+    bool              allow_cursor        = true;
+    float             keyboard_zoom_speed = 350.0f;
+    // TODO: read (with enable_experimental) but nothing applies it.
+    float system_pan_momentum = 0.4f;
+    // How much of the pan speed is kept each frame after a drag or key is released.
+    float system_pan_momentum_falloff = 0.8f;
+    bool  disable_target_camera_lock  = false;
+    // TODO: the F11 borderless toggle needs a SetWindowLongW detour that was never installed, so this does nothing.
+    bool borderless_fullscreen = true;
+    // TODO: read but nothing applies it.
+    float transition_time        = 0.01f;
+    float default_system_zoom    = 1750.0f;
+    float system_zoom_preset_1   = 50.0f;
+    float system_zoom_preset_2   = 500.0f;
+    float system_zoom_preset_3   = 1250.0f;
+    float system_zoom_preset_4   = 2750.0f;
+    float system_zoom_preset_5   = 5000.0f;
+    bool  use_presets_as_default = true;
+    // Replace the login background, and the transition (section change) backgrounds.
+    bool loader_enabled    = true;
+    bool loader_transition = true;
+    // Transitions keep the game's black background and only get the logos.
+    bool loader_transition_black = false;
+    // A PNG to use instead of the embedded loading image.
+    std::string loader_image;
+    float       loader_logo_scale      = 1.0f;
+    bool        loader_tip_enabled     = true;
+    bool        galactic_anomaly_timer = false;
+  } graphics;
+
+  struct Buffs {
+    bool use_out_of_dock_power = true;
+  } buffs;
+
+  struct Audio {
+    bool              disable_all_events       = false;
+    NotificationSound alert_victory            = NotificationSound::None;
+    NotificationSound alert_defeat             = NotificationSound::None;
+    NotificationSound alert_armada_created     = NotificationSound::None;
+    NotificationSound alert_armada_battle_won  = NotificationSound::None;
+    NotificationSound alert_armada_battle_lost = NotificationSound::None;
+
+    bool                     trace_events = false;
+    std::vector<std::string> disabled_events;
+  } audio;
+
+  struct Ui {
+    bool dock_syncmanagement         = true;
+    bool auto_confirm_reveal_ability = false;
+    bool show_player_title           = true;
+    bool only_show_first_popup       = false;
+    bool reverse_haven_history       = true;
+    bool disable_escape_exit         = true;
+    // Maximum gap in milliseconds between two Escape presses that opens the exit prompt; 0 never opens it.
+    int  disable_escape_exit_timer = 0;
+    bool disable_preview_locate    = false;
+    bool disable_preview_recall    = false;
+    // TODO: both are read but have no effect; disable_first_popup was switched off in misc.cc.
+    bool disable_first_popup   = false;
+    bool disable_toast_banners = false;
+    bool disable_move_keys     = false;
+    bool disable_galaxy_chat   = false;
+    bool disable_veil_chat     = false;
+
+    // Side chat: its initial width in canvas units (0 keeps the game's), and opening it once per login.
+    float default_chat_width = 0.0f;
+    bool  auto_open_chat     = false;
+
+    bool                     auto_open_bulk_claim_flyout = false;
+    std::vector<std::string> daily_bulk_claim_factions{"federation", "klingon", "romulan"};
+    bool                     daily_bulk_claim_toggle_default_on = false;
+
+    InstantWarpConfirmation               auto_confirm_instant_warp = InstantWarpConfirmation::kNone;
+    ShipFilter                            instant_warp_auto_jump;
+    ShipFilter                            instant_warp_auto_warp;
+    ShipFilter                            instant_warp_always_ask;
+    std::vector<std::vector<std::string>> pinned_ships;
+
+    bool double_click_to_assign_ship = false;
+    bool focus_search                = true;
+    // Abbreviated cargo values use cargo_significant_decimals.
+    bool format_cargo_values = true;
+    // Restores the Below Deck Ability officer sort option.
+    bool officer_sort              = true;
+    bool arrow_keys_to_select_ship = true;
+    bool auto_confirm_ft_upgrade   = false;
+    // Shows the equipped ship below the Forbidden Tech header, including ships without a dock.
+    bool forbidden_tech_ship_name  = true;
+    bool auto_confirm_alliance_contribution = false;
+
+    int  extend_chest_purchase_max = 160;
+    bool extend_donation_slider    = true;
+    int  extend_donation_max       = 80;
+
+    bool show_cargo_default    = true;
+    bool show_player_cargo     = true;
+    bool show_station_cargo    = true;
+    bool show_hostile_cargo    = true;
+    bool show_armada_cargo     = true;
+    bool instant_cargo_counter = true;
+    // Decimal places in abbreviated cargo values such as 1.25M.
+    int cargo_significant_decimals = 2;
+
+    bool always_skip_reveal_sequence = true;
+    // Hides the artifact shards popup's Exchange All button; single exchanges stay. Takes effect on the next popup.
+    bool disable_exchange_all = false;
+    // Mission HUD buttons by name (q_trials, field_training, outposts, daily_goals, missions).
+    std::map<std::string, MissionHudVisibility, std::less<>> mission_hud_buttons;
+
+    // ToastState values.
+    std::vector<int> disabled_banner_types;
+    std::vector<int> notify_banner_types;
+
+    [[nodiscard]] MissionHudVisibility MissionHudButtonVisibility(std::string_view button) const;
+  } ui;
+
+  struct Sync {
+    bool debug   = false;
+    bool logging = false;
+    // Seconds that resolved player and alliance names stay cached.
+    int resolver_cache_ttl = 300;
+    // The categories any target wants, so the game hooks can skip the rest.
+    SyncConfig                              options;
+    std::map<std::string, SyncTargetConfig> targets;
+  } sync;
+
+  // [config]: overrides for the game's own server settings.
+  struct Game {
+    std::string settings_url;
+    std::string assets_url_override;
+  } game;
+
+private:
+  Config() = default;
+  // Applies `file`. The first load also creates the settings file if it is missing.
+  void Load(const SettingsFile& file, bool first);
 };
diff --git a/mods/src/defaultconfig.h b/mods/src/defaultconfig.h
deleted file mode 100644
index 1d98dab81..000000000
--- a/mods/src/defaultconfig.h
+++ /dev/null
@@ -1,326 +0,0 @@
-#pragma once
-
-namespace DefaultConfig
-{
-namespace Buffs
-{
-  constexpr bool use_out_of_dock_power = true;
-} // namespace Buffs
-
-namespace Audio
-{
-  constexpr const char* disabled_events = "";
-  constexpr bool        trace_events    = false;
-  constexpr const char* alert_victory = "none";
-  constexpr const char* alert_defeat = "none";
-  constexpr const char* alert_armada_created = "none";
-  constexpr const char* alert_armada_battle_won = "none";
-  constexpr const char* alert_armada_battle_lost = "none";
-} // namespace Audio
-
-namespace SystemConfig
-{
-  constexpr const char* assets_url_override = "";
-  constexpr const char* settings_url        = "";
-} // namespace SystemConfig
-
-namespace Control
-{
-  constexpr bool enable_experimental             = false;
-  constexpr bool hotkeys_enabled                 = true;
-  constexpr bool hotkeys_extended                = true;
-  constexpr bool primary_requires_visible_target = false;
-  constexpr bool use_scopely_hotkeys             = false;
-  constexpr bool queue_enabled                   = true;
-  constexpr bool kirshara_fixes                  = true;
-  constexpr auto select_timer                    = 500;
-} // namespace Control
-
-namespace Graphics
-{
-  constexpr bool        galactic_anomaly_timer          = false;
-  constexpr bool        borderless_fullscreen           = true;
-  constexpr bool        allow_cursor                    = true;
-  constexpr const char* zoom_label_player_detail        = "native";
-  constexpr auto        zoom_label_player_threshold     = 0.5;
-  constexpr const char* zoom_label_non_player_detail    = "native";
-  constexpr auto        zoom_label_non_player_threshold = 0.5;
-  constexpr auto        default_system_zoom             = 1750;
-  constexpr bool        free_resize                     = true;
-  constexpr auto        keyboard_zoom_speed             = 350;
-  constexpr auto        system_pan_momentum_falloff     = 0.8;
-  constexpr bool        disable_target_camera_lock = false;
-  constexpr auto        system_pan_momentum             = 0.4;
-  constexpr auto        system_zoom_preset_1            = 50;
-  constexpr auto        system_zoom_preset_2            = 500;
-  constexpr auto        system_zoom_preset_3            = 1250;
-  constexpr auto        system_zoom_preset_4            = 2750;
-  constexpr auto        system_zoom_preset_5            = 5000;
-  constexpr auto        transition_time                 = 0.01;
-  constexpr auto        ui_scale                        = 0.6;
-  constexpr auto        ui_scale_step                   = 0.05;
-  constexpr auto        ui_scale_ship                   = 1.0;
-  constexpr auto        ui_scale_viewer                 = 1.2;
-  constexpr bool        use_presets_as_default          = true;
-  constexpr auto        zoom                            = 5000;
-  constexpr auto        haven_zoom                      = 4000.0;
-  constexpr auto        interior_zoom_scale             = 2.0; // station-interior zoom-out multiplier; 1.0 = native
-  constexpr auto        fr_scale                        = 2.0;
-  constexpr bool        loader_enabled                  = true; // replace LoginSequence background
-  constexpr bool        loader_transition               = true; // replace TVC/SlideShow backgrounds
-#ifdef _USE_ORIGINAL_BG
-  constexpr bool loader_transition_black = true; // original BG mode: use black transition
-#else
-  constexpr bool loader_transition_black = false; // transition: use black BG instead of custom image
-#endif
-  constexpr const char* loader_image       = "";   // Empty = use embedded fallback
-  constexpr auto        loader_logo_scale  = 1.0;  // multiplier for logo size
-  constexpr bool        loader_tip_enabled = true; // show custom tip on loading screen
-} // namespace Graphics
-
-namespace Patches
-{
-  constexpr bool bufffixhooks               = true;
-  constexpr bool chatpatches                = true;
-  constexpr bool chattitledisplayhooks      = true;
-  constexpr bool freeresizehooks            = true;
-  constexpr bool game_version               = true;
-  constexpr bool hotkeyhooks                = true;
-  constexpr bool loadingscreenhooks         = true;
-  constexpr bool transitionscreenhooks      = true;
-  constexpr bool objecttracker              = true;
-  constexpr bool panhooks                   = true;
-  constexpr bool syncpatches                = true;
-  constexpr bool tempcrashfixes             = true;
-  constexpr bool testpatches                = true;
-  constexpr bool toastbannerhooks           = true;
-  constexpr bool uiscalehooks               = true;
-  constexpr bool zoomhooks                  = true;
-  constexpr bool havenzoomhooks             = true;
-  constexpr bool interiorzoomhooks          = true;
-  constexpr bool miscpatches                = true;
-  constexpr bool giftsbulkclaimhooks        = true;
-  constexpr bool dailyfactionbulkclaimhooks = true;
-  constexpr bool missionhudtweakshooks      = true;
-  constexpr bool galacticanomalytimerhooks  = true;
-  constexpr bool loadingtiphooks            = true;
-  constexpr bool doubleclickassignshiphooks = true;
-  constexpr bool forbiddentechconfirmhooks  = true;
-  constexpr bool forbiddentechshipnamehooks = true;
-  constexpr bool audioeventhooks            = true;
-  constexpr bool actionqueuerecoveryhooks   = true;
-  constexpr bool queueaddressguardhooks     = true;
-  constexpr bool thinqueueprotectionhooks   = true;
-  constexpr bool artifactexchangehooks      = true;
-  constexpr bool instantcargocounterhooks   = true;
-  constexpr bool cargoformathooks           = true; // on by default: cargo number precision override
-  constexpr bool officersorthooks           = true; // restore Below Deck Ability sort option
-  constexpr bool pinnedshiphooks            = true; // pin configured ships to front of fleet dock sort
-  constexpr bool pinnedshipclicktoggle      = true; // SHIFT+click a fleet dock ship tile to pin/unpin it
-  constexpr bool havenhistoryhooks          = true; // reverse Haven help history into newest-first order
-  constexpr bool revealconfirmhooks         = true; // auto-confirm the Excelsior Decloaking Deflector popup when enabled in [ui]
-  constexpr bool alliancegamesstorehooks   = true; // repair Alliance Games store research/currency/refresh
-} // namespace Patches
-
-namespace Shortcuts
-{
-  constexpr const char* toggle_queue         = "CTRL-Q";
-  constexpr const char* action_queue         = "SPACE|MOUSE1";
-  constexpr const char* action_queue_clear   = "CTRL-C";
-  constexpr const char* action_primary       = "SPACE|MOUSE1";
-  constexpr const char* action_recall        = "R|MOUSE3";
-  constexpr const char* action_recall_cancel = "SPACE|MOUSE1";
-  constexpr const char* action_repair        = "R|MOUSE3";
-  constexpr const char* action_secondary     = "TAB|MOUSE4";
-  constexpr const char* action_view          = "V|MOUSE2";
-  constexpr const char* set_hotkeys_disabled = "CTRL-ALT-MINUS";
-  constexpr const char* set_hotkeys_enabled  = "CTRL-ALT-=";
-  constexpr const char* log_off              = "CTRL-SHIFT-F12";
-  constexpr const char* log_error            = "CTRL-SHIFT-F11";
-  constexpr const char* log_warn             = "CTRL-SHIFT-F10";
-  constexpr const char* log_debug            = "CTRL-SHIFT-F9";
-  constexpr const char* log_info             = "CTRL-SHIFT-F8";
-  constexpr const char* log_trace            = "CTRL-SHIFT-F7";
-  constexpr const char* restart              = "F9";
-  constexpr const char* quit                 = "F10";
-  constexpr const char* select_chatalliance  = "CTRL-2";
-  constexpr const char* select_chatglobal    = "CTRL-1";
-  constexpr const char* select_chatprivate   = "CTRL-3";
-  constexpr const char* select_current       = "CTRL-SPACE";
-  constexpr const char* select_ship1         = "1";
-  constexpr const char* select_ship2         = "2";
-  constexpr const char* select_ship3         = "3";
-  constexpr const char* select_ship4         = "4";
-  constexpr const char* select_ship5         = "5";
-  constexpr const char* select_ship6         = "6";
-  constexpr const char* select_ship7         = "7";
-  constexpr const char* select_ship8         = "8";
-  constexpr const char* focus_search         = "CTRL-F";
-  constexpr const char* set_zoom_default     = "CTRL-=";
-  constexpr const char* set_zoom_preset1     = "SHIFT-F1";
-  constexpr const char* set_zoom_preset2     = "SHIFT-F2";
-  constexpr const char* set_zoom_preset3     = "SHIFT-F3";
-  constexpr const char* set_zoom_preset4     = "SHIFT-F4";
-  constexpr const char* set_zoom_preset5     = "SHIFT-F5";
-
-  constexpr const char* show_events_native = "CTRL-E";
-  constexpr const char* show_galaxy_native = "CTRL-G";
-
-  constexpr const char* show_alliance         = "ALT-'";
-  constexpr const char* show_alliance_armada  = "CTRL-'";
-  constexpr const char* show_alliance_help    = "SHIFT-'";
-  constexpr const char* show_artifacts        = "SHIFT-I";
-  constexpr const char* show_awayteam         = "T";
-  constexpr const char* show_bookmarks        = "B";
-  constexpr const char* show_chat             = "C";
-  constexpr const char* show_chatside1        = "ALT-C";
-  constexpr const char* show_chatside2        = "`";
-  constexpr const char* show_commander        = "O";
-  constexpr const char* show_daily            = "Z";
-  constexpr const char* show_events           = "SHIFT-E";
-  constexpr const char* show_exocomp          = "X";
-  constexpr const char* show_factions         = "F";
-  constexpr const char* show_galaxy           = "G";
-  constexpr const char* show_gifts            = "/";
-  constexpr const char* show_inventory        = "I";
-  constexpr const char* show_lookup           = "L";
-  constexpr const char* show_missions         = "M";
-  constexpr const char* show_officers         = "SHIFT-O";
-  constexpr const char* show_officerpresets   = "CTRL-O";
-  constexpr const char* show_officerswap      = "ALT-O";
-  constexpr const char* show_qtrials          = "SHIFT-Q";
-  constexpr const char* show_refinery         = "SHIFT-F";
-  constexpr const char* show_research         = "U";
-  constexpr const char* show_scrapyard        = "Y";
-  constexpr const char* show_settings         = "SHIFT-S";
-  constexpr const char* show_ships            = "N";
-  constexpr const char* show_shipconstruction = "SHIFT-N";
-  constexpr const char* show_shipswap         = "ALT-N";
-  constexpr const char* show_shields          = "CTRL-S";
-  constexpr const char* show_battlelogs       = "SHIFT-B";
-  constexpr const char* show_stationexterior  = "SHIFT-G";
-  constexpr const char* show_stationinterior  = "SHIFT-H";
-  constexpr const char* show_haven            = "ALT-H";
-  constexpr const char* show_system           = "H";
-  constexpr const char* toggle_shortcut_hints = "HOME";
-  constexpr const char* toggle_cargo_armada   = "ALT-5";
-  constexpr const char* toggle_cargo_default  = "ALT-1";
-  constexpr const char* toggle_cargo_hostile  = "ALT-4";
-  constexpr const char* toggle_cargo_player   = "ALT-2";
-  constexpr const char* toggle_cargo_station  = "ALT-3";
-  constexpr const char* toggle_instant_warp   = "ALT-I";
-  constexpr const char* toggle_preview_locate = "CTRL-R";
-  constexpr const char* toggle_preview_recall = "CTRL-T";
-  constexpr const char* ui_scaledown          = "PGDOWN";
-  constexpr const char* ui_scaleup            = "PGUP";
-  constexpr const char* ui_scaleshipdown      = "CTRL-PGDOWN";
-  constexpr const char* ui_scaleshipup        = "CTRL-PGUP";
-  constexpr const char* ui_scaleviewerdown    = "SHIFT-PGDOWN";
-  constexpr const char* ui_scaleviewerup      = "SHIFT-PGUP";
-  constexpr const char* zoom_in               = "Q";
-  constexpr const char* zoom_max              = "MINUS";
-  constexpr const char* zoom_min              = "BACKSPACE";
-  constexpr const char* zoom_out              = "E";
-  constexpr const char* zoom_reset            = "=";
-  constexpr const char* zoom_preset1          = "F1";
-  constexpr const char* zoom_preset2          = "F2";
-  constexpr const char* zoom_preset3          = "F3";
-  constexpr const char* zoom_preset4          = "F4";
-  constexpr const char* zoom_preset5          = "F5";
-  constexpr const char* move_up               = "W|UP";
-  constexpr const char* move_down             = "S|DOWN";
-  constexpr const char* move_left             = "A|LEFT";
-  constexpr const char* move_right            = "D|RIGHT";
-} // namespace Shortcuts
-
-namespace Sync
-{
-  constexpr const char* stfcdata_url       = "https://sync.stfcdata.de";
-  constexpr const char* spocksclub_url     = "https://spocks.club/sync/ingress/";
-  constexpr const char* nextspocksclub_url = "https://next.spocks.club/sync/ingress/";
-
-  constexpr bool        away_assignments   = true;
-  constexpr bool        battlelogs         = false;
-  constexpr bool        buffs              = true;
-  constexpr bool        buildings          = true;
-  constexpr bool        fleets             = false; // opt-in: live fleet state from fleet_watch
-  constexpr bool        haven              = true;
-  constexpr bool        inventory          = true;
-  constexpr bool        jobs               = true;
-  constexpr bool        missions           = true;
-  constexpr bool        officers           = true;
-  constexpr bool        profile            = false;
-  constexpr const char* proxy              = "";
-  constexpr bool        research           = true;
-  constexpr bool        resources          = true;
-  constexpr bool        ships              = true;
-  constexpr bool        slots              = true;
-  constexpr bool        store_offers       = false;
-  constexpr bool        tech               = true;
-  constexpr bool        traits             = true;
-  constexpr const char* token              = "";
-  constexpr const char* url                = "";
-  constexpr bool        debug              = false;
-  constexpr bool        logging            = false;
-  constexpr bool        verify_ssl         = true;
-  constexpr auto        resolver_cache_ttl = 300;
-} // namespace Sync
-
-namespace UI
-{
-  constexpr bool        always_skip_reveal_sequence        = true;
-  constexpr bool        arrow_keys_to_select_ship          = true;
-  constexpr bool        dock_syncmanagement                = true;
-  constexpr bool        auto_confirm_discovery             = true;
-  constexpr bool        auto_confirm_ft_upgrade            = false;
-  constexpr bool        forbidden_tech_ship_name           = true;
-  constexpr bool        auto_confirm_reveal_ability        = false;
-  constexpr bool        auto_confirm_alliance_contribution = false;
-  constexpr bool        auto_open_bulk_claim_flyout        = false;
-  constexpr const char* daily_bulk_claim_factions          = "federation,klingon,romulan";
-  constexpr bool        daily_bulk_claim_toggle_default_on = false;
-  constexpr bool        only_show_first_popup              = false;
-  constexpr bool        disable_escape_exit                = true;
-  // Maximum gap between Escape presses that opens the exit prompt.
-  // 0 disables double-tap and preserves the existing blocked behavior.
-  constexpr auto        disable_escape_exit_timer   = 0;
-  constexpr bool        disable_first_popup         = false;
-  constexpr float       default_chat_width          = 0.0f;
-  constexpr bool        auto_open_chat              = false;
-  constexpr bool        disable_galaxy_chat         = false;
-  constexpr bool        disable_move_keys           = false;
-  constexpr bool        disable_preview_locate      = false;
-  constexpr bool        disable_preview_recall      = false;
-  constexpr bool        disable_toast_banners       = false;
-  constexpr bool        disable_veil_chat           = false;
-  constexpr bool        show_player_title           = true;
-  constexpr bool        disable_exchange_all        = false;
-  constexpr bool        double_click_to_assign_ship = false;
-  constexpr bool        focus_search                = true;
-  constexpr bool        format_cargo_values         = true;
-  constexpr bool        officer_sort                = true;
-  constexpr bool        reverse_haven_history       = true;
-  constexpr const char* disabled_banner_types       = "";
-  constexpr const char* hud_field_training          = "auto";
-  constexpr const char* hud_missions                = "auto";
-  constexpr const char* hud_outposts                = "auto";
-  constexpr const char* hud_q_trials                = "auto";
-  constexpr const char* auto_confirm_instant_warp   = "none";
-  constexpr const char* instant_warp_auto_jump      = "";
-  constexpr const char* instant_warp_auto_warp      = "";
-  constexpr const char* instant_warp_always_ask     = "";
-  constexpr const char* pinned_ships                = "";
-  constexpr const char* notify_banner_types         = "";
-  constexpr auto        extend_chest_purchase_max   = 160;
-  constexpr auto        extend_donation_max         = 80;
-  constexpr bool        extend_donation_slider      = true;
-  constexpr bool        show_armada_cargo           = true;
-  constexpr bool        show_cargo_default          = true;
-  constexpr bool        show_hostile_cargo          = true;
-  constexpr bool        show_player_cargo           = true;
-  constexpr bool        show_station_cargo          = true;
-  constexpr bool        instant_cargo_counter       = true;
-  constexpr int         cargo_significant_decimals  = 2; // decimal places for abbreviated cargo values (e.g. 1.25M)
-} // namespace UI
-
-} // namespace DefaultConfig
diff --git a/mods/src/eastl_new.cc b/mods/src/eastl_new.cc
new file mode 100644
index 000000000..96eac364f
--- /dev/null
+++ b/mods/src/eastl_new.cc
@@ -0,0 +1,13 @@
+// The allocation hooks EASTL requires every program to define. Its containers free with operator delete[], so
+// these must stay plain malloc: honouring `alignment` with an aligned allocator would mismatch that free.
+
+#include <cstddef>
+#include <cstdlib>
+
+void* operator new[](size_t size, const char* /*name*/, int /*flags*/, unsigned /*debugFlags*/, const char* /*file*/,
+                     int /*line*/)
+{ return malloc(size); }
+
+void* operator new[](size_t size, size_t /*alignment*/, size_t /*alignmentOffset*/, const char* /*name*/, int /*flags*/,
+                     unsigned /*debugFlags*/, const char* /*file*/, int /*line*/)
+{ return malloc(size); }
diff --git a/mods/src/errormsg.h b/mods/src/errormsg.h
deleted file mode 100644
index acaa9d7f0..000000000
--- a/mods/src/errormsg.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include "str_utils.h"
-
-#include <spdlog/spdlog.h>
-
-#if _WIN32
-#include <winrt/Windows.Foundation.h>
-#endif
-
-namespace ErrorMsg
-{
-static void SyncMsg(const char* section, const std::string& msg)
-{
-  spdlog::error("Failed to send {} sync data: {}", section, msg);
-}
-
-static void SyncMsg(const char* section, const std::wstring& msg)
-{
-  spdlog::error("Failed to send {} sync data: {}", section, to_string(msg));
-}
-
-static void SyncRuntime(const char* section, const std::runtime_error& e)
-{
-  spdlog::error("Runtime error sending {} sync data: {}", section, e.what());
-}
-
-static void SyncException(const char* section, const std::exception& e)
-{
-  spdlog::error("Exception sending {} sync data: {}", section, e.what());
-}
-
-#if _WIN32
-static void SyncWinRT(const char* section, winrt::hresult_error const& ex)
-{
-  spdlog::error("WINRT Error sending {} sync data: {}", section, winrt::to_string(ex.message()));
-}
-#endif
-};
diff --git a/mods/src/file.cc b/mods/src/file.cc
index 424480740..256b03aca 100644
--- a/mods/src/file.cc
+++ b/mods/src/file.cc
@@ -1,282 +1,195 @@
 #include "file.h"
-#include "windowtitle.h"
 
-#if __APPLE__
-#include <crt_externs.h>
-#endif
+#include <spdlog/spdlog.h>
 
-#if _WIN32
-std::string ConvertWStringToString(const std::wstring& wstr)
-{
-  if (wstr.empty())
-    return std::string();
+#include <fstream>
+#include <vector>
 
-  int         sizeNeeded = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), nullptr, 0, nullptr, nullptr);
-  std::string str(sizeNeeded, 0);
-  WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &str[0], sizeNeeded, nullptr, nullptr);
-
-  return str;
-}
+#if _WIN32
+#include <Windows.h>
+#include <shellapi.h>
+#elif __APPLE__
+#include <crt_externs.h>
 #endif
- 
-std::filesystem::path File::Path()
-{
-  if (!File::initialized) {
-    File::Init();
-  }
 
-  return configPath;
-}
+#if __APPLE__
+std::filesystem::path MacLibraryDirectory(); // file_macos.mm
+#endif
 
-const char* File::Default()
+namespace
 {
-  if (!File::initialized) {
-    File::Init();
-  }
+constexpr std::string_view kDefaultConfig  = "community_patch_settings.toml";
+constexpr std::string_view kDefaultVars    = "community_patch_runtime.vars";
+constexpr std::string_view kDefaultLog     = "community_patch.log";
+constexpr std::string_view kDefaultBattles = "patch_battlelogs_sent.json";
+
+// Names used by older releases.
+constexpr std::string_view kLegacyVars   = "community_path_runtime.vars";
+constexpr std::string_view kLegacyParsed = "community_patch_settings_parsed.toml";
+
+std::string           config_name, vars_name, log_name, battles_name, profile;
+const std::string     default_config{kDefaultConfig};
+std::filesystem::path profile_path;
+#ifdef _MODDBG
+bool debug = true;
+#else
+bool debug = false;
+#endif
+bool trace = false;
 
-  return cacheNameDefault.c_str();
-}
+// std::filesystem::path(std::string) uses the ANSI code page on Windows; the mod's strings are UTF-8.
+std::filesystem::path FromUtf8(std::string_view text)
+{ return std::u8string(text.begin(), text.end()); }
 
-const char* File::Config()
+std::string ToUtf8(const std::filesystem::path& path)
 {
-  if (!File::initialized) {
-    File::Init();
-  }
-
-  return cacheNameConfig.c_str();
+  const auto text = path.u8string();
+  return {text.begin(), text.end()};
 }
 
-const char* File::Vars()
+std::vector<std::string> Arguments()
 {
-  if (!File::initialized) {
-    File::Init();
+  std::vector<std::string> args;
+#if _WIN32
+  int  argc = 0;
+  auto argv = CommandLineToArgvW(GetCommandLineW(), &argc);
+  if (!argv)
+    return args;
+  for (int i = 0; i < argc; ++i) {
+    const auto  size = WideCharToMultiByte(CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr);
+    std::string arg(size > 0 ? size - 1 : 0, '\0');
+    WideCharToMultiByte(CP_UTF8, 0, argv[i], -1, arg.data(), size, nullptr, nullptr);
+    args.push_back(std::move(arg));
   }
-
-  return cacheNameVar.c_str();
+  LocalFree(argv);
+#elif __APPLE__
+  const int argc = *_NSGetArgc();
+  char**    argv = *_NSGetArgv();
+  args.assign(argv, argv + argc);
+#endif
+  return args;
 }
 
-const char* File::Log()
+std::filesystem::path Directory(bool legacy = false)
 {
-  if (!File::initialized) {
-    File::Init();
-  }
-
-  return cacheNameLog.c_str();
+  if (!profile_path.empty())
+    return profile_path.parent_path();
+#if __APPLE__
+  return MacLibraryDirectory() / "Preferences" / (legacy ? "com.tashcan.startrekpatch" : "com.stfcmod.startrekpatch");
+#else
+  (void)legacy;
+  return {};
+#endif
 }
 
-const char* File::Battles()
+// Settings used to live in com.tashcan.startrekpatch. Move that folder over once and leave a symlink and a note
+// behind for anyone who still looks there.
+void MigrateMacPreferences()
 {
-  if (!File::initialized) {
-    File::Init();
+#if __APPLE__
+  namespace fs         = std::filesystem;
+  const auto file_path = File::Path(config_name);
+  const auto new_dir   = file_path.parent_path();
+  if (fs::exists(file_path) || fs::exists(new_dir))
+    return;
+
+  const auto old_dir  = Directory(true);
+  const auto old_path = old_dir / config_name;
+  if (!fs::is_regular_file(old_path))
+    return;
+
+  spdlog::info("mac config migration: moving {} to {}", ToUtf8(old_dir), ToUtf8(new_dir));
+  try {
+    fs::rename(old_dir, new_dir);
+    fs::create_directories(old_dir);
+    fs::create_symlink(file_path, old_path);
+
+    std::ofstream info(old_dir / "update-info.txt");
+    info << "Your config has been moved!\n\n";
+    info << "You can now find your config at " << file_path << "\n\n";
+    info << "A symlink has been placed for your convenience, but it is generally recommended, that you use the new "
+            "path and delete this directory going forward.";
+  } catch (const std::exception& error) {
+    spdlog::warn("mac config migration failed: {}", error.what());
   }
-
-  return cacheNameBattles.c_str();
+#endif
 }
+} // namespace
 
-std::wstring File::Title()
+namespace File
 {
-  if (!File::initialized) {
-    File::Init();
-  }
-
-  if (cacheNameTitle.empty()) {
-    std::wstring title = WindowTitle::Get();
-
-    if (File::override && !title.empty()) {
-      cacheNameTitle = L"[" + configPath.filename().replace_extension().wstring() + L"] " + title;
-    }
-  }
-
-  return cacheNameTitle;
-}
-
-#if !_WIN32
-std::u8string File::MakePath(std::string_view filename, bool create_dir, bool old_path)
+void Init()
 {
-  std::filesystem::path config_dir;
-  if (File::override) {
-    config_dir = configPath.parent_path();
-  } else {
-    const std::filesystem::path libraryPath =
-        fm::FolderManager::pathForDirectory(fm::NSLibraryDirectory, fm::NSUserDomainMask);
-    const auto packageName = old_path ? "com.tashcan.startrekpatch" : "com.stfcmod.startrekpatch";
-    config_dir             = libraryPath / "Preferences" / packageName;
+  const auto args = Arguments();
+  for (size_t i = 1; i < args.size(); ++i) {
+    if (args[i] == "-debug")
+      debug = true;
+    else if (args[i] == "-trace")
+      trace = true;
+    else if (args[i] == "-ccm" && i + 1 < args.size())
+      profile_path = FromUtf8(args[++i]);
   }
 
-  if (create_dir) {
-    std::error_code ec;
-    std::filesystem::create_directories(config_dir, ec);
+  if (profile_path.empty()) {
+    config_name  = kDefaultConfig;
+    vars_name    = kDefaultVars;
+    log_name     = kDefaultLog;
+    battles_name = kDefaultBattles;
+    return;
   }
-  std::filesystem::path config_path = config_dir / filename;
-  return config_path.u8string();
-}
-#else
-std::string_view File::MakePath(std::string_view filename, bool create_dir, bool old_path)
-{
-  return filename;
-}
-#endif
-
-void File::Init()
-{
-  if (!File::initialized) {
-    File::override = false;
-
-    /*******************************
-     *
-     * Set the default config file name
-     *
-     *******************************/
-
-    cacheNameDefault = std::filesystem::path(FILE_DEF_CONFIG).string();
-
-    /*******************************
-     *
-     * Check for command line argument
-     * override and set config path
-     *
-     *******************************/
-#if _WIN32
-    // Get the command line
-    LPCWSTR cmdLine = GetCommandLineW();
-
-    // Parse command line into individual arguments
-    int     argc;
-    LPWSTR* argv = CommandLineToArgvW(cmdLine, &argc);
-
-    // If we have some arguments, lets see what we got
-    std::wstring argValue;
-    if (argv != nullptr) {
-      // Output the arguments (for example purposes, we'll just print them)
-      for (int i = 0; i < argc - 1; ++i) {
-        if (std::wstring(argv[i]) == L"-debug") {
-          File::debug = true;
-        }
 
-        if (std::wstring(argv[i]) == L"-trace") {
-          File::trace = true;
-        }
+  profile             = ToUtf8(profile_path.stem());
+  auto with_extension = [](const char* extension) {
+    return ToUtf8(std::filesystem::path(profile_path).replace_extension(extension));
+  };
+  config_name  = with_extension(".toml");
+  vars_name    = with_extension(".vars");
+  log_name     = with_extension(".log");
+  battles_name = with_extension(".json");
+}
 
-        if (std::wstring(argv[i]) == L"-ccm" && i + 1 < argc) {
-          // Found "-ccm", so take the next argument as the value
-          argValue = argv[i + 1];
-          break;
-        }
-      }
+const std::string& Config()
+{ return config_name; }
 
-      if (!argValue.empty()) {
-        File::override = true;
-        configPath     = std::filesystem::path(ConvertWStringToString(argValue));
-      }
+const std::string& Vars()
+{ return vars_name; }
 
-      // Clean up
-      LocalFree(argv);
-    }
-#elif __APPLE__
-    {
-      int    argc = *_NSGetArgc();
-      char** argv = *_NSGetArgv();
-      for (int i = 0; i < argc - 1; ++i) {
-        if (std::string_view(argv[i]) == "-debug") {
-          File::debug = true;
-        }
-        if (std::string_view(argv[i]) == "-trace") {
-          File::trace = true;
-        }
-        if (std::string_view(argv[i]) == "-ccm" && i + 1 < argc) {
-          configPath     = std::filesystem::path(argv[i + 1]);
-          File::override = true;
-          break;
-        }
-      }
-    }
-#endif
+const std::string& Log()
+{ return log_name; }
 
-    if (configPath.empty()) {
-      File::override = false;
-      configPath     = std::filesystem::path(cacheNameDefault);
-    }
+const std::string& Battles()
+{ return battles_name; }
 
-    /*******************************
-     *
-     * Set the battle log file name
-     *
-     *******************************/
-    if (File::override) {
-      cacheNameBattles = configPath.replace_extension(FILE_EXT_JSON).string();
-    } else {
-      cacheNameBattles = std::string(FILE_DEF_BL);
-    }
+const std::string& DefaultConfig()
+{ return default_config; }
 
-    /*******************************
-     *
-     * Set the log file name
-     *
-     *******************************/
-    if (File::override) {
-      cacheNameLog = configPath.replace_extension(FILE_EXT_LOG).string();
-    } else {
-      cacheNameLog = std::string(FILE_DEF_LOG);
-    }
+const std::string& Profile()
+{ return profile; }
 
-    /*******************************
-     *
-     * Set the vars file name
-     *
-     *******************************/
+bool Debug()
+{ return debug; }
 
-    if (File::override) {
-      cacheNameVar = configPath.replace_extension(FILE_EXT_VARS).string();
-    } else {
-      cacheNameVar = std::string(FILE_DEF_VARS);
-    }
+bool Trace()
+{ return trace; }
 
-    /*******************************
-     *
-     * Set the config file name
-     *
-     *******************************/
-    if (File::override) {
-      cacheNameConfig = configPath.replace_extension(FILE_EXT_TOML).string();
-    } else {
-      cacheNameConfig = std::string(FILE_DEF_CONFIG);
-    }
-
-    File::initialized = true;
-  }
-}
-
-bool File::hasCustomNames()
+std::filesystem::path Path(std::string_view name, bool create_dir)
 {
-  return File::override;
+  const auto dir = Directory();
+  if (create_dir && !dir.empty()) {
+    std::error_code ignored;
+    std::filesystem::create_directories(dir, ignored);
+  }
+  // A -ccm profile path is already complete; joining an absolute path replaces the directory.
+  return dir / FromUtf8(name).filename();
 }
 
-bool File::hasDebug()
+void MigrateLegacyFiles()
 {
-  return File::debug;
-}
+  MigrateMacPreferences();
 
-bool File::hasTrace()
-{
-  return File::trace;
+  std::error_code ignored;
+  std::filesystem::remove(Path(kLegacyVars), ignored);
+  if (std::filesystem::remove(Path(kLegacyParsed), ignored))
+    spdlog::info("Removed {} (old parsed file)", kLegacyParsed);
 }
-
-#ifdef _MODDBG
-bool File::debug = true;
-#else
-bool File::debug = false;
-#endif
-
-bool File::trace       = false;
-bool File::override    = false;
-bool File::initialized = false;
-
-std::wstring File::cacheNameTitle = L"";
-
-std::string File::cacheNameBattles = "";
-std::string File::cacheNameLog     = "";
-std::string File::cacheNameVar     = "";
-std::string File::cacheNameConfig  = "";
-std::string File::cacheNameDefault = "";
-
-std::filesystem::path File::configPath = "";
+} // namespace File
diff --git a/mods/src/file.h b/mods/src/file.h
index ce07efbfc..cdce7510a 100644
--- a/mods/src/file.h
+++ b/mods/src/file.h
@@ -1,75 +1,34 @@
-#include "config.h"
-#include "patches/mapkey.h"
-#include "prime/KeyCode.h"
-#include "str_utils.h"
-#include "version.h"
-#include <prime\Toast.h>
+#pragma once
 
-#include <EASTL/tuple.h>
-#include <spdlog/spdlog.h>
+// Where the mod's settings, runtime vars, log, and battle-log cache live, and the command-line flags that change
+// them. `-ccm <path>` selects a profile: every file is named after it instead of the defaults.
 
-#include <algorithm>
-#include <cstdio>
 #include <filesystem>
-#include <iostream>
 #include <string>
 #include <string_view>
 
-#if !_WIN32
-#include "folder_manager.h"
-#else
-#include <shellapi.h>
-#include <windows.h>
-#endif
-
-// Original output file names
-#define FILE_DEF_CONFIG "community_patch_settings.toml"
-#define FILE_DEF_LOG "community_patch.log"
-#define FILE_DEF_VARS "community_patch_runtime.vars"
-#define FILE_DEF_VARS_OLD "community_path_runtime.vars"
-#define FILE_DEF_BL "patch_battlelogs_sent.json"
-#define FILE_DEF_PARSED "community_patch_settings_parsed.toml"
-#define FILE_DEF_TITLE L"Star Trek Fleet Command"
-
-#define FILE_EXT_TOML ".toml"
-#define FILE_EXT_VARS ".vars"
-#define FILE_EXT_LOG ".log"
-#define FILE_EXT_JSON ".json"
-
-class File
+namespace File
 {
-public:
-  static void         Init();
-  static std::wstring Title();
-  static const char*  Default();
-  static const char*  Config();
-  static const char*  Vars();
-  static const char*  Log();
-  static const char*  Battles();
-  static bool         hasCustomNames();
-  static bool         hasDebug();
-  static bool         hasTrace();
-
-#if _WIN32
-  static std::string_view MakePath(std::string_view filename, bool create_dir = false, bool old_path = false);
-#else
-  static std::u8string MakePath(std::string_view filename, bool create_dir = false, bool old_path = false);
-#endif
-
-private:
-  static std::filesystem::path Path();
-
-  static bool debug;
-  static bool trace;
-  static bool override;
-  static bool initialized;
-
-  static std::wstring cacheNameTitle;
-  static std::string  cacheNameBattles;
-  static std::string  cacheNameLog;
-  static std::string  cacheNameVar;
-  static std::string  cacheNameConfig;
-  static std::string  cacheNameDefault;
-
-  static std::filesystem::path configPath;
-};
+// Parses the command line. Call once, before anything else here.
+void Init();
+
+// File names as configured, relative to Path().
+const std::string& Config();
+const std::string& Vars();
+const std::string& Log();
+const std::string& Battles();
+// The settings file name used without -ccm, for messages that point users at it.
+const std::string& DefaultConfig();
+
+// The -ccm profile name ("alt" for -ccm alt.toml), or empty without -ccm.
+const std::string& Profile();
+bool               Debug();
+bool               Trace();
+
+// Full path of a mod file. On macOS this is ~/Library/Preferences/com.stfcmod.startrekpatch unless -ccm points
+// elsewhere; on Windows it is the game's working directory.
+std::filesystem::path Path(std::string_view name, bool create_dir = false);
+
+// Moves settings left behind by older releases. Logs, so call after the logger is up.
+void MigrateLegacyFiles();
+} // namespace File
diff --git a/mods/src/file_macos.mm b/mods/src/file_macos.mm
new file mode 100644
index 000000000..d6614152b
--- /dev/null
+++ b/mods/src/file_macos.mm
@@ -0,0 +1,15 @@
+#include <filesystem>
+
+#import <Foundation/Foundation.h>
+
+// ~/Library for the current user. Copied out of the autoreleased NSURL before the pool drains.
+std::filesystem::path MacLibraryDirectory()
+{
+  @autoreleasepool {
+    NSArray<NSURL*>* urls = [[NSFileManager defaultManager] URLsForDirectory:NSLibraryDirectory
+                                                                   inDomains:NSUserDomainMask];
+    if (urls.count == 0)
+      return std::filesystem::path(NSHomeDirectory().fileSystemRepresentation) / "Library";
+    return urls.firstObject.path.fileSystemRepresentation;
+  }
+}
diff --git a/mods/src/folder_manager.h b/mods/src/folder_manager.h
deleted file mode 100644
index 96c6d2547..000000000
--- a/mods/src/folder_manager.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-
-namespace fm
-{
-enum {
-  NSApplicationDirectory = 1,
-  NSDemoApplicationDirectory,
-  NSDeveloperApplicationDirectory,
-  NSAdminApplicationDirectory,
-  NSLibraryDirectory,
-  NSDeveloperDirectory,
-  NSUserDirectory,
-  NSDocumentationDirectory,
-  NSDocumentDirectory,
-  NSCoreServiceDirectory,
-  NSAutosavedInformationDirectory = 11,
-  NSDesktopDirectory              = 12,
-  NSCachesDirectory               = 13,
-  NSApplicationSupportDirectory   = 14,
-  NSDownloadsDirectory            = 15,
-  NSInputMethodsDirectory         = 16,
-  NSMoviesDirectory               = 17,
-  NSMusicDirectory                = 18,
-  NSPicturesDirectory             = 19,
-  NSPrinterDescriptionDirectory   = 20,
-  NSSharedPublicDirectory         = 21,
-  NSPreferencePanesDirectory      = 22,
-  NSApplicationScriptsDirectory   = 23,
-  NSItemReplacementDirectory      = 99,
-  NSAllApplicationsDirectory      = 100,
-  NSAllLibrariesDirectory         = 101,
-  NSTrashDirectory                = 102
-};
-typedef unsigned long SearchPathDirectory;
-
-enum {
-  NSUserDomainMask = 1, // user's home directory --- place to install user's personal items (~)
-  NSLocalDomainMask =
-      2, // local to the current machine --- place to install items available to everyone on this machine (/Library)
-  NSNetworkDomainMask = 4,     // publically available location in the local area network --- place to install items
-                               // available on the network (/Network)
-  NSSystemDomainMask = 8,      // provided by Apple, unmodifiable (/System)
-  NSAllDomainsMask   = 0x0ffff // all domains: all of the above and future items
-};
-typedef unsigned long SearchPathDomainMask;
-
-class FolderManager
-{
-public:
-  static const char *pathForDirectory(SearchPathDirectory directory, SearchPathDomainMask domainMask);
-  static const char *pathForDirectoryAppropriateForItemAtPath(SearchPathDirectory  directory,
-                                                              SearchPathDomainMask domainMask, const char *itemPath,
-                                                              bool create = false);
-};
-}; // namespace fm
diff --git a/mods/src/folder_manager.mm b/mods/src/folder_manager.mm
deleted file mode 100644
index 33ec3ca32..000000000
--- a/mods/src/folder_manager.mm
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "folder_manager.h"
-
-#import <Foundation/Foundation.h>
-
-using namespace fm;
-
-const char * FolderManager::pathForDirectory(SearchPathDirectory directory, SearchPathDomainMask domainMask) {
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-    NSArray *URLs = [fileManager URLsForDirectory:(NSSearchPathDirectory)directory inDomains:domainMask];
-    if (URLs.count == 0) return NULL;
-
-    NSURL *URL = [URLs objectAtIndex:0];
-    NSString *path = URL.path;
-
-    // `fileSystemRepresentation` on an `NSString` gives a path suitable for POSIX APIs
-    return path.fileSystemRepresentation;
-}
-
-const char * FolderManager::pathForDirectoryAppropriateForItemAtPath(SearchPathDirectory directory,
- SearchPathDomainMask domainMask, const char *itemPath, bool create) {
-
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-    NSString *nsPath = [fileManager stringWithFileSystemRepresentation:itemPath length:strlen(itemPath)];
-    NSURL *itemURL = (nsPath ? [NSURL fileURLWithPath:nsPath] : nil);
-
-    NSURL *URL = [fileManager URLForDirectory:(NSSearchPathDirectory)directory
-                       inDomain:domainMask
-              appropriateForURL:itemURL
-                         create:create error:NULL];
-    return URL.path.fileSystemRepresentation;
-}
\ No newline at end of file
diff --git a/mods/src/il2cpp/method_contract.h b/mods/src/il2cpp/method_contract.h
index d7d1ccdc5..b96778bba 100644
--- a/mods/src/il2cpp/method_contract.h
+++ b/mods/src/il2cpp/method_contract.h
@@ -42,3 +42,5 @@ inline const MethodInfo* Resolve(Il2CppClass* cls, const char* name, bool is_sta
 inline void* Pointer(const MethodInfo* method)
 { return method ? reinterpret_cast<void*>(method->methodPointer) : nullptr; }
 } // namespace method_contract
+
+namespace il2cpp { namespace contract = ::method_contract; }
diff --git a/mods/src/mod.h b/mods/src/mod.h
new file mode 100644
index 000000000..30481cf0e
--- /dev/null
+++ b/mods/src/mod.h
@@ -0,0 +1,6 @@
+#pragma once
+
+// The mod's entry point for the platform loaders.
+
+// Loads GameAssembly and hooks il2cpp_init, which installs everything else once the runtime is up.
+void StartMod();
diff --git a/mods/src/patches/battle_notify_parser.cc b/mods/src/patches/battle_notify_parser.cc
deleted file mode 100644
index 903824a67..000000000
--- a/mods/src/patches/battle_notify_parser.cc
+++ /dev/null
@@ -1,366 +0,0 @@
-#include "patches/battle_notify_parser.h"
-
-#include "str_utils.h"
-
-#include <il2cpp/il2cpp.h>
-#include <prime/BattleResultHeader.h>
-#include <prime/HullSpec.h>
-#include <prime/LocaleTextContext.h>
-#include <prime/SpecService.h>
-#include <prime/Toast.h>
-#include <prime/UserProfile.h>
-
-#include <spdlog/spdlog.h>
-#include <spdlog/fmt/fmt.h>
-
-#include <string>
-
-#if _WIN32
-#include <windows.h>
-#endif
-
-// ---------------------------------------------------------------------------
-// SEH wrapper — catches access violations from bad IL2CPP pointers
-// ---------------------------------------------------------------------------
-template <typename Fn>
-static bool seh_call(Fn fn)
-{
-#if _WIN32
-  __try {
-    fn();
-    return true;
-  } __except (EXCEPTION_EXECUTE_HANDLER) {
-    return false;
-  }
-#else
-  fn();
-  return true;
-#endif
-}
-
-// ---------------------------------------------------------------------------
-// IL2CPP localization infrastructure
-// ---------------------------------------------------------------------------
-namespace {
-
-using SystemObject = il2cpp::Class<"mscorlib", "System", "Object">;
-using SystemInt64  = il2cpp::Class<"mscorlib", "System", "Int64">;
-
-// Create a LocaleTextContext(identifier, category), apply the given parameter,
-// and call LocaleUtilities.Localize. Returns empty string on failure.
-std::string localize(const char* identifier, const char* category, Il2CppObject* param)
-{
-  auto* object_class = SystemObject::Raw();
-  if (!object_class || !param) return {};
-
-  std::string result;
-  if (!seh_call([&] {
-        auto* idStr  = il2cpp_string_new(identifier);
-        auto* catStr = il2cpp_string_new(category);
-
-        auto* arr = il2cpp::Array<Il2CppObject*>::New(object_class, 1);
-        if (!arr) return;
-        arr->Set(0, param);
-
-        auto* ltc = il2cpp::New<LocaleTextContext>(idStr, catStr);
-        if (!ltc) return;
-
-        ltc->ApplyIdentifierParameters(arr);
-        if (auto* ret = LocaleUtilities::Localize(ltc, false, false))
-          result = to_string(ret);
-      }))
-    spdlog::warn("[Notify] SEH: localize crashed for \"{}/{}\"", identifier, category);
-  return result;
-}
-
-// Box an int64 as Il2CppObject for use as a localization parameter.
-Il2CppObject* box_int64(int64_t value)
-{
-  auto* int64_class = SystemInt64::Raw();
-  return int64_class ? il2cpp_value_box(int64_class, &value) : nullptr;
-}
-
-} // namespace
-
-// ---------------------------------------------------------------------------
-// Hull name key → human-readable name
-//   "Hull_L30_Destroyer_Klingon_LIVE" → "Lv.30 Destroyer Klingon"
-// ---------------------------------------------------------------------------
-static std::string parse_hull_key(const std::string& key)
-{
-  auto s = key;
-
-  if (s.size() > 5 && s.ends_with("_LIVE"))
-    s = s.substr(0, s.size() - 5);
-  if (s.starts_with("Hull_"))
-    s = s.substr(5);
-
-  for (auto& c : s)
-    if (c == '_') c = ' ';
-
-  if (s.size() >= 2 && s[0] == 'L' && std::isdigit(s[1])) {
-    auto space = s.find(' ');
-    auto lvl   = s.substr(1, space == std::string::npos ? std::string::npos : space - 1);
-    auto rest  = space == std::string::npos ? "" : s.substr(space);
-    s = "Lv." + lvl + rest;
-  }
-
-  bool newWord = true;
-  for (auto& c : s) {
-    if (newWord && std::isalpha(static_cast<unsigned char>(c))) {
-      c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
-      newWord = false;
-    } else if (!newWord && std::isalpha(static_cast<unsigned char>(c))) {
-      c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-    }
-    if (c == ' ') newWord = true;
-  }
-
-  return s;
-}
-
-// ---------------------------------------------------------------------------
-// Localization helpers — thin wrappers over localize()
-// ---------------------------------------------------------------------------
-
-// Hull name via numeric locaId: "ship_name_{0}" / "ships"
-static std::string localize_hull_name(int64_t locaId)
-{
-  auto* boxed = box_int64(locaId);
-  return boxed ? localize("ship_name_{0}", "ships", boxed) : std::string{};
-}
-
-// Hull name via string locaStringId: "ship_name_{0}" / "ships"
-static std::string localize_hull_name(const std::string& locaStringId)
-{
-  auto* strObj = il2cpp_string_new(locaStringId.c_str());
-  return localize("ship_name_{0}", "ships", reinterpret_cast<Il2CppObject*>(strObj));
-}
-
-// Enemy commander name via locaId: "marauder_name_only_{0}" / "navigation"
-static std::string localize_enemy_name(int64_t locaId)
-{
-  auto* boxed = box_int64(locaId);
-  return boxed ? localize("marauder_name_only_{0}", "navigation", boxed) : std::string{};
-}
-
-// ---------------------------------------------------------------------------
-// Resolve hull ID → display name via SpecService + game localization
-// ---------------------------------------------------------------------------
-static std::string resolve_hull_name(BattleResultHeader* brh, int64_t hullId)
-{
-  if (hullId == 0) return "";
-
-  auto* specSvc = static_cast<SpecService*>(brh->get_SpecService());
-  if (!specSvc) return fmt::format("Hull#{}", hullId);
-
-  auto* hull = specSvc->GetHull(hullId);
-  if (!hull) return fmt::format("Hull#{}", hullId);
-
-  std::string locaStringId;
-  int64_t locaId = 0;
-  if (auto* idRefs = hull->idRefs()) {
-    if (auto* locaStrPtr = idRefs->locaStringId()) locaStringId = to_string(locaStrPtr);
-    locaId = idRefs->locaId();
-  }
-
-  // Try numeric locaId first, then string locaStringId, then manual parse
-  if (locaId != 0) {
-    auto localized = localize_hull_name(locaId);
-    if (!localized.empty() && localized != fmt::format("ship_name_{}", locaId))
-      return localized;
-  }
-  if (!locaStringId.empty()) {
-    auto localized = localize_hull_name(locaStringId);
-    if (!localized.empty() && localized != fmt::format("ship_name_{}", locaStringId))
-      return localized;
-  }
-
-  auto* nameStr = hull->Name();
-  if (!nameStr) return fmt::format("Hull#{}", hullId);
-  return parse_hull_key(to_string(nameStr));
-}
-
-// ---------------------------------------------------------------------------
-// Normalize ALL CAPS ship names to Title Case
-// ---------------------------------------------------------------------------
-static std::string normalize_ship_name(std::string name)
-{
-  bool nextUpper = true;
-  for (auto& c : name) {
-    if (nextUpper && c >= 'a' && c <= 'z')
-      c = std::toupper(static_cast<unsigned char>(c));
-    else if (!nextUpper && c >= 'A' && c <= 'Z')
-      c = std::tolower(static_cast<unsigned char>(c));
-    nextUpper = (c == ' ' || c == '-' || c == '_');
-  }
-  return name;
-}
-
-// ---------------------------------------------------------------------------
-// Battle summary data model
-// ---------------------------------------------------------------------------
-struct BattleSummaryData {
-  std::string playerName;
-  std::string enemyName;
-  std::string playerShip;
-  std::string enemyShip;
-  bool isPvp = false;
-
-  // Format as "Player (Ship) vs Enemy (Ship)".
-  // For non-PVP battles with a localized enemy name, the enemy ship class is omitted.
-  std::string format_body() const
-  {
-    auto format_side = [](const std::string& name, const std::string& ship) -> std::string {
-      if (!name.empty() && !ship.empty()) return fmt::format("{} ({})", name, ship);
-      if (!name.empty()) return name;
-      if (!ship.empty()) return ship;
-      return "";
-    };
-
-    auto left  = format_side(playerName, playerShip);
-    auto right = (!isPvp && !enemyName.empty()) ? enemyName : format_side(enemyName, enemyShip);
-
-    if (left.empty() && right.empty()) return "";
-    if (left.empty()) return right;
-    if (right.empty()) return left;
-    return left + " vs " + right;
-  }
-};
-
-// ---------------------------------------------------------------------------
-// Extract player/enemy names + ship hulls from BattleResultHeader
-// ---------------------------------------------------------------------------
-static BattleSummaryData build_battle_data(Il2CppObject* data)
-{
-  BattleSummaryData result;
-  if (!data) return result;
-
-  auto* brh = static_cast<il2cpp::Object*>(data)->As<BattleResultHeader>();
-  if (!brh) return result;
-
-  if (!seh_call([&] {
-        auto* profile = static_cast<UserProfile*>(brh->get_PlayerUserProfile());
-        if (profile && profile->Name())
-          result.playerName = to_string(profile->Name());
-      }))
-    spdlog::warn("[Notify] SEH: get_PlayerUserProfile crashed");
-
-  if (!seh_call([&] {
-        auto* profile = static_cast<UserProfile*>(brh->get_EnemyUserProfile());
-        if (profile) {
-          if (profile->Name())
-            result.enemyName = to_string(profile->Name());
-          // NPC/marauder profiles have empty names — localize via LocaId
-          if (result.enemyName.empty()) {
-            auto locaId = profile->LocaId();
-            if (locaId != 0) {
-              auto localized = localize_enemy_name(locaId);
-              if (!localized.empty() && localized != "Unknown")
-                result.enemyName = localized;
-            }
-          }
-        }
-      }))
-    spdlog::warn("[Notify] SEH: get_EnemyUserProfile crashed");
-
-  // PVP battle types — for non-PVP we drop the enemy hull classification
-  if (!seh_call([&] {
-        auto bt = brh->get_BattleType();
-        result.isPvp = (bt == static_cast<int>(BattleType::Fleet) ||
-                        bt == static_cast<int>(BattleType::Base) ||
-                        bt == static_cast<int>(BattleType::ArmadaBase) ||
-                        bt == static_cast<int>(BattleType::ArmadaAsb) ||
-                        bt == static_cast<int>(BattleType::ArmadaMta) ||
-                        bt == static_cast<int>(BattleType::PvpCuttingBeam) ||
-                        bt == static_cast<int>(BattleType::PvpChainShot));
-      }))
-    spdlog::warn("[Notify] SEH: get_BattleType crashed");
-
-  if (!seh_call([&] {
-        result.playerShip = normalize_ship_name(resolve_hull_name(brh, brh->PlayerShipHullId()));
-      }))
-    spdlog::warn("[Notify] SEH: PlayerShipHullId crashed");
-
-  if (!seh_call([&] {
-        result.enemyShip = normalize_ship_name(resolve_hull_name(brh, brh->EnemyShipHullId()));
-      }))
-    spdlog::warn("[Notify] SEH: EnemyShipHullId crashed");
-
-  return result;
-}
-
-// Toast data types vary by state, so fields resolve on the receiver's runtime class.
-template <il2cpp::Name N, typename T>
-static T read_instance_field(Il2CppObject* obj)
-{
-  return obj ? static_cast<il2cpp::Object*>(obj)->Field<N, T>() : T{};
-}
-
-static std::string build_armada_created_body(Il2CppObject* data)
-{
-  std::string result;
-  if (!seh_call([&] {
-        auto* attack   = read_instance_field<"ArmadaAttack", Il2CppObject*>(data);
-        auto* alliance = read_instance_field<"Alliance", Il2CppObject*>(data);
-        auto* owner    = read_instance_field<"<Owner>k__BackingField", Il2CppObject*>(attack);
-        auto* target   = read_instance_field<"<TargetUserProfile>k__BackingField", Il2CppObject*>(attack);
-
-        auto* tag_value   = read_instance_field<"tag_", Il2CppString*>(alliance);
-        auto* owner_value = read_instance_field<"name_", Il2CppString*>(owner);
-        auto* target_value = read_instance_field<"name_", Il2CppString*>(target);
-
-        auto tag         = tag_value ? to_string(tag_value) : std::string{};
-        auto owner_name  = owner_value ? to_string(owner_value) : std::string{};
-        auto target_name = target_value ? to_string(target_value) : std::string{};
-        auto target_level = read_instance_field<"<TargetLevel>k__BackingField", int32_t>(attack);
-
-        if (target_name.empty()) {
-          auto loca_id = read_instance_field<"_locaId", int64_t>(target);
-          if (loca_id != 0) target_name = localize_enemy_name(loca_id);
-        }
-
-        if (owner_name.empty()) owner_name = "An alliance member";
-        if (target_name.empty() || target_name == "Unknown") target_name = "Armada target";
-
-        auto owner_label = tag.empty() ? owner_name : fmt::format("[{}] {}", tag, owner_name);
-        result = fmt::format("{} started an Armada!\nLv.{:03} {}", owner_label, target_level, target_name);
-      })) {
-    spdlog::warn("[Notify] SEH: ArmadaCreated data parsing crashed");
-    return {};
-  }
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-std::string battle_notify_parse(Toast* toast)
-{
-  if (toast->get_State() == ArmadaCreated)
-    return build_armada_created_body(toast->get_Data());
-
-  switch (toast->get_State()) {
-    case Victory:
-    case Defeat:
-    case PartialVictory:
-    case StationVictory:
-    case StationDefeat:
-    case StationBattle:
-    case IncomingAttack:
-    case FleetBattle:
-    case ArmadaBattleWon:
-    case ArmadaBattleLost:
-    case AssaultVictory:
-    case AssaultDefeat:
-      break;
-    default:
-      return {};
-  }
-
-  auto* data = toast->get_Data();
-  if (!data) return {};
-
-  auto bsd = build_battle_data(data);
-  return bsd.format_body();
-}
diff --git a/mods/src/patches/battle_notify_parser.h b/mods/src/patches/battle_notify_parser.h
deleted file mode 100644
index 258167325..000000000
--- a/mods/src/patches/battle_notify_parser.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-
-#include <string>
-
-struct Toast;
-
-// Attempt to build a detailed notification body from a battle toast's Data.
-// Returns empty string if the toast has no battle data or parsing fails.
-std::string battle_notify_parse(Toast* toast);
diff --git a/mods/src/patches/fleet_watch.cc b/mods/src/patches/fleet_watch.cc
index e4189c28d..6acd07c4f 100644
--- a/mods/src/patches/fleet_watch.cc
+++ b/mods/src/patches/fleet_watch.cc
@@ -1,9 +1,6 @@
 #include "patches/fleet_watch.h"
 
-#include "errormsg.h"
-#include "patches/screen_update_hook.h"
-
-#include <prime/FleetsManager.h>
+#include <prime/fleet.h>
 
 #include <spdlog/spdlog.h>
 
@@ -11,9 +8,7 @@
 #include <array>
 #include <chrono>
 #include <cstddef>
-#include <cstdlib>
 #include <exception>
-#include <string_view>
 #include <vector>
 
 namespace
@@ -21,10 +16,6 @@ namespace
 constexpr int     kFleetSlotCount             = 10;
 constexpr int64_t kManagerProbeIntervalMs     = 250;
 constexpr int64_t kManagerDiscoveryIntervalMs = 5'000;
-constexpr int64_t kFastPollIntervalMs         = 250;
-constexpr int64_t kFastPollBackoffMs          = 5'000;
-constexpr int64_t kFastPollPeriodMs           = 30'000;
-constexpr int64_t kFastPollLifetimeMs         = 24LL * 60 * 60 * 1'000;
 constexpr int64_t kSeedIntervalMs             = 1'000;
 constexpr int64_t kSeedBackoffIntervalMs      = 5'000;
 constexpr int64_t kSeedFastPeriodMs           = 30'000;
@@ -33,11 +24,9 @@ constexpr int64_t kSeedStabilizationMs        = 5'000;
 constexpr int64_t kSeedMaxStabilizationMs     = 30'000;
 
 struct ObservedFleet {
-  uint64_t   fleet_id             = 0;
-  FleetState state                = FleetState::Unknown;
-  bool       occupied             = false;
-  int64_t    fast_poll_started_ms = 0;
-  bool       fast_poll_exhausted  = false;
+  uint64_t   fleet_id = 0;
+  FleetState state    = FleetState::Unknown;
+  bool       occupied = false;
 };
 
 std::array<ObservedFleet, kFleetSlotCount> s_slots{};
@@ -53,14 +42,8 @@ int64_t                                    s_seed_last_change_ms       = 0;
 int64_t                                    s_last_seed_attempt_ms      = 0;
 int64_t                                    s_last_manager_probe_ms     = 0;
 int64_t                                    s_last_manager_discovery_ms = 0;
-int64_t                                    s_last_fast_poll_ms         = 0;
 int                                        s_manager_probe_slot        = 0;
-int                                        s_fast_poll_count           = 0;
 int                                        s_dispatch_depth            = 0;
-bool                                       s_evaluating_fast_poll      = false;
-#ifdef _MODDBG
-bool s_runtime_probe_enabled = false;
-#endif
 
 class CallbackScope
 {
@@ -78,36 +61,6 @@ int64_t now_milliseconds()
       .count();
 }
 
-bool needs_fast_poll(FleetState state)
-{
-  if (s_evaluating_fast_poll) {
-    spdlog::warn("[FleetWatch] suppressed recursive fast-poll predicate evaluation");
-    return false;
-  }
-  s_evaluating_fast_poll = true;
-  struct PredicateScope {
-    ~PredicateScope()
-    { s_evaluating_fast_poll = false; }
-  } predicate_scope;
-  CallbackScope callback_scope;
-
-  for (const auto& subscription : s_subscriptions) {
-    if (!subscription.needs_fast_poll) {
-      continue;
-    }
-    try {
-      if (subscription.needs_fast_poll(state)) {
-        return true;
-      }
-    } catch (const std::exception& error) {
-      spdlog::warn("[FleetWatch] fast-poll predicate failed: {}", error.what());
-    } catch (...) {
-      spdlog::warn("[FleetWatch] fast-poll predicate failed with an unknown exception");
-    }
-  }
-  return false;
-}
-
 void reset_observation()
 {
   s_slots                     = {};
@@ -121,9 +74,7 @@ void reset_observation()
   s_last_seed_attempt_ms      = 0;
   s_last_manager_probe_ms     = 0;
   s_last_manager_discovery_ms = 0;
-  s_last_fast_poll_ms         = 0;
   s_manager_probe_slot        = 0;
-  s_fast_poll_count           = 0;
 }
 
 void restart_seed(int slot, uint64_t fleet_id)
@@ -132,14 +83,6 @@ void restart_seed(int slot, uint64_t fleet_id)
   reset_observation();
 }
 
-void clear_slot(int slot)
-{
-  if (s_slots[slot].occupied && s_slots[slot].fast_poll_started_ms != 0) {
-    --s_fast_poll_count;
-  }
-  s_slots[slot] = {};
-}
-
 int occupied_slot_count()
 {
   return static_cast<int>(
@@ -198,24 +141,10 @@ void observe_fleet(FleetPlayerData* fleet, int requested_slot, bool publish)
     restart_seed(slot, fleet_id);
   }
 
-  const bool changed = !same_state;
-
-  const bool was_fast_polling = previous.occupied && previous.fast_poll_started_ms != 0;
-  int64_t    fast_started_ms  = 0;
-  const bool fast_exhausted   = same_state && previous.fast_poll_exhausted;
-  if (!fast_exhausted && needs_fast_poll(state)) {
-    fast_started_ms = same_fleet && was_fast_polling ? previous.fast_poll_started_ms : now_milliseconds();
-  }
+  const bool changed        = !same_state;
   const auto previous_state = previous.state;
-  previous                  = ObservedFleet{fleet_id, state, true, fast_started_ms, fast_exhausted};
+  previous                  = ObservedFleet{fleet_id, state, true};
 
-  const bool is_fast_polling = fast_started_ms != 0;
-  if (was_fast_polling != is_fast_polling) {
-    s_fast_poll_count += is_fast_polling ? 1 : -1;
-    if (is_fast_polling && s_fast_poll_count == 1) {
-      s_last_fast_poll_ms = 0;
-    }
-  }
   if (s_seed_pending && changed) {
     const auto now_ms = now_milliseconds();
     if (!s_seed_has_observation) {
@@ -231,14 +160,12 @@ void observe_fleet(FleetPlayerData* fleet, int requested_slot, bool publish)
 }
 
 struct ScanResult {
-  int      observed_count    = 0;
-  bool     manager_available = false;
-  bool     topology_changed  = false;
-  int      changed_slot      = -1;
-  uint64_t changed_fleet     = 0;
+  int  observed_count    = 0;
+  bool manager_available = false;
 };
 
-ScanResult scan_manager(bool publish, bool only_fast_polling)
+// Reads every slot while a baseline is being established. Transitions are not published from here.
+ScanResult scan_manager()
 {
   ScanResult result;
   auto*      manager = FleetsManager::Instance();
@@ -248,57 +175,34 @@ ScanResult scan_manager(bool publish, bool only_fast_polling)
   result.manager_available = true;
 
   std::array<FleetPlayerData*, kFleetSlotCount> fleets{};
+  bool                                          topology_changed = false;
   for (int slot = 0; slot < kFleetSlotCount; ++slot) {
-    if (only_fast_polling && (!s_slots[slot].occupied || s_slots[slot].fast_poll_started_ms == 0)) {
-      continue;
-    }
     fleets[slot] = manager->GetFleetPlayerData(slot);
     if (fleets[slot]) {
       ++result.observed_count;
     }
-    if (only_fast_polling) {
-      continue;
-    }
     const bool occupied = fleets[slot] != nullptr;
     const auto fleet_id = occupied ? fleets[slot]->Id() : 0;
     if (s_slots[slot].occupied != occupied || (occupied && s_slots[slot].fleet_id != fleet_id)) {
-      result.topology_changed = true;
-      if (result.changed_slot < 0) {
-        result.changed_slot  = slot;
-        result.changed_fleet = fleet_id;
-      }
+      topology_changed = true;
     }
   }
 
-  if (result.topology_changed && publish && !s_seed_pending) {
-    restart_seed(result.changed_slot, result.changed_fleet);
-    publish = false;
-  } else if (result.topology_changed && s_seed_pending && s_seed_has_observation) {
+  if (topology_changed && s_seed_pending && s_seed_has_observation) {
     s_seed_last_change_ms     = now_milliseconds();
     s_seed_finalize_candidate = false;
   }
 
   for (int slot = 0; slot < kFleetSlotCount; ++slot) {
-    if (only_fast_polling && (!s_slots[slot].occupied || s_slots[slot].fast_poll_started_ms == 0)) {
-      continue;
-    }
     if (fleets[slot]) {
-      observe_fleet(fleets[slot], slot, publish);
-    } else if (!only_fast_polling) {
-      clear_slot(slot);
+      observe_fleet(fleets[slot], slot, false);
+    } else {
+      s_slots[slot] = {};
     }
   }
   s_seed_manager_backed = true;
   return result;
 }
-
-bool install_observer()
-{
-  if (!install_screen_manager_update_hook()) {
-    return false;
-  }
-  return register_screen_manager_update_callback(fleet_watch::Tick);
-}
 } // namespace
 
 namespace fleet_watch
@@ -316,9 +220,6 @@ bool Subscribe(Subscription subscription)
   }
 
   if (!s_observer_installed) {
-    if (!install_observer()) {
-      return false;
-    }
     s_observer_installed = true;
     reset_observation();
   }
@@ -341,7 +242,7 @@ void Tick()
     const auto interval = lifetime < kSeedFastPeriodMs ? kSeedIntervalMs : kSeedBackoffIntervalMs;
     if (s_last_seed_attempt_ms == 0 || now_ms - s_last_seed_attempt_ms >= interval) {
       s_last_seed_attempt_ms = now_ms;
-      const auto scan        = scan_manager(false, false);
+      const auto scan        = scan_manager();
       if (s_seed_manager_backed && !scan.manager_available) {
         reset_observation();
         return;
@@ -361,7 +262,7 @@ void Tick()
           s_seed_finalize_candidate = true;
           return;
         }
-        const auto final_scan = scan_manager(false, false);
+        const auto final_scan = scan_manager();
         if (!forced && now_ms - s_seed_last_change_ms < kSeedStabilizationMs) {
           s_seed_finalize_candidate = false;
           return;
@@ -370,13 +271,7 @@ void Tick()
           const auto baseline_count = final_scan.observed_count > 0 ? final_scan.observed_count : occupied_slot_count();
           s_seed_pending            = false;
           s_last_manager_probe_ms   = now_ms;
-          s_last_fast_poll_ms       = s_fast_poll_count > 0 ? now_ms : 0;
           spdlog::debug("[FleetWatch] established stable baseline for {} fleet slots", baseline_count);
-#ifdef _MODDBG
-          if (s_runtime_probe_enabled) {
-            spdlog::info("[FleetWatchProbe] established stable baseline for {} fleet slots", baseline_count);
-          }
-#endif
           if (final_scan.manager_available) {
             dispatch_baseline();
           }
@@ -421,58 +316,5 @@ void Tick()
       observe_fleet(fleet, slot, true);
     }
   }
-
-  if (s_fast_poll_count <= 0) {
-    return;
-  }
-  bool fast_period = false;
-  for (auto& slot : s_slots) {
-    if (!slot.occupied || slot.fast_poll_started_ms == 0) {
-      continue;
-    }
-    const auto lifetime = now_ms - slot.fast_poll_started_ms;
-    if (lifetime >= kFastPollLifetimeMs) {
-      slot.fast_poll_started_ms = 0;
-      slot.fast_poll_exhausted  = true;
-      --s_fast_poll_count;
-    } else if (lifetime < kFastPollPeriodMs) {
-      fast_period = true;
-    }
-  }
-  const auto interval = fast_period ? kFastPollIntervalMs : kFastPollBackoffMs;
-  if (s_fast_poll_count > 0 && (s_last_fast_poll_ms == 0 || now_ms - s_last_fast_poll_ms >= interval)) {
-    s_last_fast_poll_ms = now_ms;
-    scan_manager(true, true);
-  }
-}
-
-#ifdef _MODDBG
-namespace
-{
-  void runtime_probe_transition(const Transition& transition)
-  {
-    spdlog::info("[FleetWatchProbe] slot={} fleet={} oldState={} newState={}", transition.after.slot,
-                 transition.after.fleet_id, static_cast<int>(transition.before.state),
-                 static_cast<int>(transition.after.state));
-  }
-
-  bool runtime_probe_fast_poll(FleetState state)
-  { return state != FleetState::Unknown; }
-} // namespace
-
-void InstallRuntimeProbe()
-{
-  const auto* enabled = std::getenv("STFC_MOD_FLEET_WATCH_PROBE");
-  if (!enabled || std::string_view{enabled} != "1") {
-    return;
-  }
-  s_runtime_probe_enabled = true;
-  if (Subscribe({runtime_probe_transition, runtime_probe_fast_poll})) {
-    spdlog::info("[FleetWatchProbe] runtime subscriber installed");
-  } else {
-    s_runtime_probe_enabled = false;
-    spdlog::warn("[FleetWatchProbe] runtime subscriber installation failed");
-  }
 }
-#endif
 } // namespace fleet_watch
diff --git a/mods/src/patches/fleet_watch.h b/mods/src/patches/fleet_watch.h
index 4e590f7c1..fd01b337b 100644
--- a/mods/src/patches/fleet_watch.h
+++ b/mods/src/patches/fleet_watch.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <prime/FleetPlayerData.h>
+#include <prime/fleet.h>
 
 namespace fleet_watch
 {
@@ -17,29 +17,22 @@ struct Transition {
 };
 
 using TransitionCallback = void (*)(const Transition& transition);
-using FastPollPredicate  = bool (*)(FleetState state);
 using BaselineCallback   = void (*)();
 
 struct Subscription {
-  TransitionCallback on_transition   = nullptr;
-  FastPollPredicate  needs_fast_poll = nullptr;
+  TransitionCallback on_transition = nullptr;
   // Optional. Runs on the game thread each time a stable baseline is established while the fleet service is available
   // (after login, and again after any fleet-slot topology change). Transitions are only dispatched after a baseline, so
   // a consumer that needs the complete fleet list reads FleetsManager here.
-  BaselineCallback   on_baseline     = nullptr;
+  BaselineCallback on_baseline = nullptr;
 };
 
-// Registers a process-lifetime fleet-state observer. The first subscription joins the shared screen-update dispatcher;
-// with no subscriptions, Fleet Watch performs no scans or IL2CPP work.
+// Registers a process-lifetime fleet-state observer. With no subscriptions, Fleet Watch performs no scans or IL2CPP
+// work.
 // Register during patch installation. Callbacks run synchronously on the game thread, and Transition::fleet is valid
 // only for the duration of the callback.
 bool Subscribe(Subscription subscription);
 
-// Called by the shared ScreenManager.Update detour. Consumers should use Subscribe rather than calling this directly.
+// Runs once a frame from the subscriber's frame work (fleet sync, the only subscriber).
 void Tick();
-
-#ifdef _MODDBG
-// Enables a raw transition logger when STFC_MOD_FLEET_WATCH_PROBE=1 for exact-artifact runtime validation.
-void InstallRuntimeProbe();
-#endif
 } // namespace fleet_watch
diff --git a/mods/src/patches/gamefunctions.h b/mods/src/patches/gamefunctions.h
deleted file mode 100644
index 7c2c8ba4d..000000000
--- a/mods/src/patches/gamefunctions.h
+++ /dev/null
@@ -1,113 +0,0 @@
-#pragma once
-
-enum GameFunction {
-  MoveLeft,
-  MoveRight,
-  MoveUp,
-  MoveDown,
-  SelectChatAlliance,
-  SelectChatGlobal,
-  SelectChatPrivate,
-  SelectShip1,
-  SelectShip2,
-  SelectShip3,
-  SelectShip4,
-  SelectShip5,
-  SelectShip6,
-  SelectShip7,
-  SelectShip8,
-  SelectCurrent,
-  ShowAlliance,
-  ShowAllianceArmada,
-  ShowAllianceHelp,
-  ShowArtifacts,
-  ShowOfficers,
-  ShowOfficerPresets,
-  ShowCommander,
-  ShowRefinery,
-  ShowQTrials,
-  ShowBookmarks,
-  ShowLookup,
-  ShowExoComp,
-  ShowFactions,
-  ShowGifts,
-  ShowDaily,
-  ShowAwayTeam,
-  ShowMissions,
-  ShowResearch,
-  ShowScrapYard,
-  ShowShips,
-  ShowInventory,
-  ShowStationInterior,
-  ShowHaven,
-  ShoWStationExterior,
-  ShowGalaxy,
-  NativeShortcutGalaxy,
-  ShowSystem,
-  ShowChat,
-  ShowChatSide1,
-  ShowChatSide2,
-  ShowEvents,
-  NativeShortcutEvents,
-  ShowSettings,
-  ToggleShortcutHints,
-  ZoomPreset1,
-  ZoomPreset2,
-  ZoomPreset3,
-  ZoomPreset4,
-  ZoomPreset5,
-  ZoomIn,
-  ZoomOut,
-  ZoomMin,
-  ZoomMax,
-  ZoomReset,
-  UiScaleUp,
-  UiScaleDown,
-  UiShipScaleUp,
-  UiShipScaleDown,
-  UiViewerScaleUp,
-  UiViewerScaleDown,
-  ActionPrimary,
-  ActionSecondary,
-  ActionQueue,
-  ActionQueueClear,
-  ActionView,
-  ActionRecall,
-  ActionRecallCancel,
-  ActionRepair,
-  SetZoomPreset1,
-  SetZoomPreset2,
-  SetZoomPreset3,
-  SetZoomPreset4,
-  SetZoomPreset5,
-  SetZoomDefault,
-  DisableHotKeys,
-  EnableHotKeys,
-  ToggleQueue,
-  ToggleAutoConfirmInstantWarp,
-  TogglePreviewLocate,
-  TogglePreviewRecall,
-  ToggleCargoDefault,
-  ToggleCargoPlayer,
-  ToggleCargoStation,
-  ToggleCargoHostile,
-  ToggleCargoArmada,
-  LogLevelDebug,
-  LogLevelInfo,
-  LogLevelTrace,
-  LogLevelError,
-  LogLevelWarn,
-  LogLevelOff,
-  Restart,
-  Quit,
-  FocusSearch,
-
-  ShowShipConstruction,
-  ShowOfficerSwap,
-  ShowShipSwap,
-  ShowShields,
-  ShowBattlelogs,
-
-  // Automatic max value
-  Max
-};
diff --git a/mods/src/patches/instant_warp_policy.h b/mods/src/patches/instant_warp_policy.h
deleted file mode 100644
index 2a1d97bae..000000000
--- a/mods/src/patches/instant_warp_policy.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-struct FleetPlayerData;
-enum class InstantWarpConfirmation;
-
-// Shared by the confirmation action and its preview on the system card.
-InstantWarpConfirmation ResolveInstantWarpConfirmation(FleetPlayerData* fleet);
-void                    InstallWarpActionLabel();
diff --git a/mods/src/patches/key.cc b/mods/src/patches/key.cc
deleted file mode 100644
index 71c3b95d5..000000000
--- a/mods/src/patches/key.cc
+++ /dev/null
@@ -1,367 +0,0 @@
-#include "key.h"
-#include "prime/EventSystem.h"
-#include "str_utils.h"
-#include <prime/TMP_InputField.h>
-
-#include <string>
-#include <string_view>
-#include <unordered_map>
-
-int Key::cacheInputFocused  = 0;
-int Key::cacheInputModified = 0;
-int Key::cacheFrame         = -1;
-
-std::array<int, (int)KeyCode::Max>  Key::cacheKeyPressed         = {};
-std::array<int, (int)KeyCode::Max>  Key::cacheKeyDown            = {};
-std::array<bool, (int)KeyCode::Max> Key::claimedDirectionalInput = {};
-
-namespace
-{
-constexpr std::array directionalKeys = {
-    KeyCode::LeftArrow,
-    KeyCode::RightArrow,
-    KeyCode::UpArrow,
-    KeyCode::DownArrow,
-};
-
-int CurrentInputFrame()
-{
-  static auto GetFrameCount = il2cpp::ResolveICall<int()>("UnityEngine.Time::get_frameCount()");
-  return GetFrameCount();
-}
-}
-
-const std::unordered_map<std::string, KeyCode> Key::mappedKeys = {
-    {"LALT", KeyCode::LeftAlt},
-    {"LAPPLE", KeyCode::LeftApple},
-    {"LCOM", KeyCode::LeftCommand},
-    {"LCTRL", KeyCode::LeftControl},
-    {"ALTGR", KeyCode::AltGr},
-    {"END", KeyCode::End},
-    {"HOME", KeyCode::Home},
-    {"PGDOWN", KeyCode::PageDown},
-    {"PGUP", KeyCode::PageUp},
-    {"DOWN", KeyCode::DownArrow},
-    {"LEFT", KeyCode::LeftArrow},
-    {"RIGHT", KeyCode::RightArrow},
-    {"UP", KeyCode::UpArrow},
-    {"BACKSPACE", KeyCode::Backspace},
-    {"BREAK", KeyCode::Break},
-    {"CAPS", KeyCode::CapsLock},
-    {"CLEAR", KeyCode::Clear},
-    {"DELETE", KeyCode::Delete},
-    {"ESCAPE", KeyCode::Escape},
-    {"HELP", KeyCode::Help},
-    {"INSERT", KeyCode::Insert},
-    {"LSHIFT", KeyCode::LeftShift},
-    {"LWIN", KeyCode::LeftWindows},
-    {"MENU", KeyCode::Menu},
-    {"PAUSE", KeyCode::Pause},
-    {"PRINT", KeyCode::Print},
-    {"RALT", KeyCode::RightAlt},
-    {"RAPPLE", KeyCode::RightApple},
-    {"RCOM", KeyCode::RightCommand},
-    {"RCTRL", KeyCode::RightControl},
-    {"RETURN", KeyCode::Return},
-    {"RSHIFT", KeyCode::RightShift},
-    {"RWIN", KeyCode::RightWindows},
-    {"SCROLL", KeyCode::ScrollLock},
-    {"SYSREQ", KeyCode::SysReq},
-    {"TAB", KeyCode::Tab},
-    {"MOUSE0", KeyCode::Mouse0},
-    {"MOUSE1", KeyCode::Mouse1},
-    {"MOUSE2", KeyCode::Mouse2},
-    {"MOUSE3", KeyCode::Mouse3},
-    {"MOUSE4", KeyCode::Mouse4},
-    {"MOUSE5", KeyCode::Mouse5},
-    {"MOUSE6", KeyCode::Mouse6},
-    {"SPACE", KeyCode::Space},
-    {"MINUS", KeyCode::Minus},
-    {"_", KeyCode::Underscore},
-    {",", KeyCode::Comma},
-    {";", KeyCode::Semicolon},
-    {":", KeyCode::Colon},
-    {"!", KeyCode::Exclaim},
-    {"?", KeyCode::Question},
-    {".", KeyCode::Period},
-    {"'", KeyCode::Quote},
-    {"(", KeyCode::LeftParen},
-    {")", KeyCode::RightParen},
-    {"[", KeyCode::LeftBracket},
-    {"]", KeyCode::RightBracket},
-    {"{", KeyCode::LeftCurlyBracket},
-    {"}", KeyCode::RightCurlyBracket},
-    {"@", KeyCode::At},
-    {"*", KeyCode::Asterisk},
-    {"/", KeyCode::Slash},
-    {"\"", KeyCode::DoubleQuote},
-    {"\\", KeyCode::Backslash},
-    {"&", KeyCode::Ampersand},
-    {"#", KeyCode::Hash},
-    {"%", KeyCode::Percent},
-    {"`", KeyCode::BackQuote},
-    {"^", KeyCode::Caret},
-    {"+", KeyCode::Plus},
-    {"<", KeyCode::Less},
-    {"=", KeyCode::Equals},
-    {">", KeyCode::Greater},
-    {"|", KeyCode::Pipe},
-    {"~", KeyCode::Tilde},
-    {"$", KeyCode::Dollar},
-    {"0", KeyCode::Alpha0},
-    {"1", KeyCode::Alpha1},
-    {"2", KeyCode::Alpha2},
-    {"3", KeyCode::Alpha3},
-    {"4", KeyCode::Alpha4},
-    {"5", KeyCode::Alpha5},
-    {"6", KeyCode::Alpha6},
-    {"7", KeyCode::Alpha7},
-    {"8", KeyCode::Alpha8},
-    {"9", KeyCode::Alpha9},
-    {"A", KeyCode::A},
-    {"B", KeyCode::B},
-    {"C", KeyCode::C},
-    {"D", KeyCode::D},
-    {"E", KeyCode::E},
-    {"F", KeyCode::F},
-    {"F1", KeyCode::F1},
-    {"F10", KeyCode::F10},
-    {"F11", KeyCode::F11},
-    {"F12", KeyCode::F12},
-    {"F13", KeyCode::F13},
-    {"F14", KeyCode::F14},
-    {"F15", KeyCode::F15},
-    {"F2", KeyCode::F2},
-    {"F3", KeyCode::F3},
-    {"F4", KeyCode::F4},
-    {"F5", KeyCode::F5},
-    {"F6", KeyCode::F6},
-    {"F7", KeyCode::F7},
-    {"F8", KeyCode::F8},
-    {"F9", KeyCode::F9},
-    {"G", KeyCode::G},
-    {"H", KeyCode::H},
-    {"I", KeyCode::I},
-    {"J", KeyCode::J},
-    {"K", KeyCode::K},
-    {"L", KeyCode::L},
-    {"M", KeyCode::M},
-    {"N", KeyCode::N},
-    {"O", KeyCode::O},
-    {"P", KeyCode::P},
-    {"Q", KeyCode::Q},
-    {"R", KeyCode::R},
-    {"S", KeyCode::S},
-    {"T", KeyCode::T},
-    {"U", KeyCode::U},
-    {"V", KeyCode::V},
-    {"W", KeyCode::W},
-    {"X", KeyCode::X},
-    {"Y", KeyCode::Y},
-    {"Z", KeyCode::Z},
-    {"NUMLOCK", KeyCode::Numlock},
-    {"KEY0", KeyCode::Keypad0},
-    {"KEY1", KeyCode::Keypad1},
-    {"KEY2", KeyCode::Keypad2},
-    {"KEY3", KeyCode::Keypad3},
-    {"KEY4", KeyCode::Keypad4},
-    {"KEY5", KeyCode::Keypad5},
-    {"KEY6", KeyCode::Keypad6},
-    {"KEY7", KeyCode::Keypad7},
-    {"KEY8", KeyCode::Keypad8},
-    {"KEY9", KeyCode::Keypad9},
-    {"KEYDIVIDE", KeyCode::KeypadDivide},
-    {"KEYENTER", KeyCode::KeypadEnter},
-    {"KEYEQUAL", KeyCode::KeypadEquals},
-    {"KEYMINUS", KeyCode::KeypadMinus},
-    {"KEYMULTI", KeyCode::KeypadMultiply},
-    {"KEYPERIOD", KeyCode::KeypadPeriod},
-    {"KEYPLUS", KeyCode::KeypadPlus},
-};
-
-KeyCode Key::Parse(std::string_view key)
-{
-  auto wantedKey = AsciiStrToUpper(key);
-  for (const auto& [value, keycode] : mappedKeys) {
-    if (wantedKey == value) {
-      return (KeyCode)keycode;
-    }
-  }
-
-  return KeyCode::None;
-}
-
-bool Key::IsModifier(KeyCode key)
-{
-  switch (key) {
-    case KeyCode::LeftAlt:
-    case KeyCode::LeftCommand:
-    case KeyCode::LeftControl:
-    case KeyCode::AltGr:
-    case KeyCode::LeftShift:
-    case KeyCode::LeftWindows:
-    case KeyCode::RightAlt:
-    case KeyCode::RightCommand:
-    case KeyCode::RightControl:
-    case KeyCode::RightShift:
-    case KeyCode::RightWindows:
-      return true;
-    default:
-      return false;
-  }
-}
-
-void Key::ClaimDirectionalInput(KeyCode key)
-{
-  switch (key) {
-    case KeyCode::LeftArrow:
-    case KeyCode::RightArrow:
-    case KeyCode::UpArrow:
-    case KeyCode::DownArrow:
-      claimedDirectionalInput[(int)key] = true;
-      break;
-    default:
-      break;
-  }
-}
-
-bool Key::IsDirectionalInputClaimed()
-{
-  EnsureCurrentFrame();
-
-  auto claimed = false;
-  for (const auto key : directionalKeys) {
-    auto& directionClaimed = claimedDirectionalInput[(int)key];
-    if (!directionClaimed) {
-      continue;
-    }
-
-    if (Pressed(key)) {
-      claimed = true;
-    } else {
-      directionClaimed = false;
-    }
-  }
-
-  return claimed;
-}
-
-bool Key::IsModified()
-{
-  EnsureCurrentFrame();
-
-  if (cacheInputModified == 0) {
-    cacheInputModified = -1;
-    if (Key::Pressed(KeyCode::LeftAlt) || Key::Pressed(KeyCode::LeftControl) || Key::Pressed(KeyCode::LeftShift)
-        || Key::Pressed(KeyCode::RightAlt) || Key::Pressed(KeyCode::RightControl) || Key::Pressed(KeyCode::RightShift)
-        || Key::Pressed(KeyCode::AltGr) || Key::Pressed(KeyCode::LeftCommand) || Key::Pressed(KeyCode::LeftWindows)
-        || Key::Pressed(KeyCode::RightCommand) || Key::Pressed(KeyCode::RightWindows)) {
-      cacheInputModified = 1;
-    }
-  }
-
-  return cacheInputModified == 1;
-}
-
-void Key::ResetCache()
-{
-  Key::cacheFrame          = CurrentInputFrame();
-  Key::cacheInputFocused  = 0;
-  Key::cacheInputModified = 0;
-  for (int i = 0; i < (int)KeyCode::Max; i++) {
-    Key::cacheKeyDown[i]    = 0;
-    Key::cacheKeyPressed[i] = 0;
-  }
-
-  // Direction claims span frames while their key is held so one-shot chords cannot leak into native movement.
-  // Prune them here as well as at the consumer so claims cannot survive a scene without NavigationPan.
-  for (const auto key : directionalKeys) {
-    auto& directionClaimed = claimedDirectionalInput[(int)key];
-    if (directionClaimed && !Pressed(key)) {
-      directionClaimed = false;
-    }
-  }
-}
-
-void Key::EnsureCurrentFrame()
-{
-  if (cacheFrame != CurrentInputFrame()) {
-    ResetCache();
-  }
-}
-
-bool Key::Down(KeyCode key)
-{
-  EnsureCurrentFrame();
-
-  static auto GetKeyDownInt =
-      il2cpp::ResolveICall<bool(KeyCode)>("UnityEngine.Input::GetKeyDownInt(UnityEngine.KeyCode)");
-
-  if (cacheKeyDown[(int)key] == 0) {
-    cacheKeyDown[(int)key] = GetKeyDownInt(key) ? 1 : -1;
-  }
-
-  return cacheKeyDown[(int)key] == 1;
-}
-
-bool Key::Pressed(KeyCode key)
-{
-  EnsureCurrentFrame();
-
-  static auto GetKeyInt = il2cpp::ResolveICall<bool(KeyCode)>("UnityEngine.Input::GetKeyInt(UnityEngine.KeyCode)");
-
-  if (cacheKeyPressed[(int)key] == 0) {
-    cacheKeyPressed[(int)key] = GetKeyInt(key) ? 1 : -1;
-  }
-
-  return cacheKeyPressed[(int)key] == 1;
-}
-
-bool Key::IsInputFocused()
-{
-  EnsureCurrentFrame();
-
-  if (cacheInputFocused == 0) {
-    cacheInputFocused = -1;
-
-    auto eventSystem = EventSystem::current();
-    if (eventSystem) {
-      auto n = eventSystem->currentSelectedGameObject();
-      if (n) {
-        auto n2 = n->GetComponent<TMP_InputField>();
-        if (n2 && n2->isFocused()) {
-          cacheInputFocused = 1;
-        }
-      }
-    }
-  }
-
-  return cacheInputFocused == 1;
-}
-
-bool Key::HasShift()
-{
-  return Key::Pressed(KeyCode::LeftShift) || Key::Pressed(KeyCode::RightShift);
-}
-
-bool Key::HasAlt()
-{
-  return Key::Pressed(KeyCode::LeftAlt) || Key::Pressed(KeyCode::RightAlt);
-}
-
-bool Key::HasCtrl()
-{
-  return Key::Pressed(KeyCode::LeftControl) || Key::Pressed(KeyCode::RightControl);
-}
-
-void Key::ClearInputFocus()
-{
-  if (auto eventSystem = EventSystem::current(); eventSystem) {
-    if (auto n = eventSystem->currentSelectedGameObject(); n) {
-      auto n2 = n->GetComponent<TMP_InputField>();
-      if (n2 && n2->isFocused()) {
-        eventSystem->SetSelectedGameObject(nullptr);
-      }
-    }
-  }
-}
diff --git a/mods/src/patches/key.h b/mods/src/patches/key.h
deleted file mode 100644
index 81211c2e0..000000000
--- a/mods/src/patches/key.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-#include <prime/KeyCode.h>
-
-#include <array>
-#include <string>
-#include <unordered_map>
-
-class Key
-{
-private:
-  static const std::unordered_map<std::string, KeyCode> mappedKeys;
-
-  static int cacheInputFocused;
-  static int cacheInputModified;
-  static int cacheFrame;
-
-  static std::array<int, (int)KeyCode::Max>  cacheKeyPressed;
-  static std::array<int, (int)KeyCode::Max>  cacheKeyDown;
-  static std::array<bool, (int)KeyCode::Max> claimedDirectionalInput;
-
-  static void EnsureCurrentFrame();
-
-public:
-  static void    ClearInputFocus();
-  static void    ResetCache();
-  static KeyCode Parse(std::string_view key);
-
-  static bool Pressed(KeyCode key);
-  static bool Down(KeyCode key);
-
-  static void ClaimDirectionalInput(KeyCode key);
-  static bool IsDirectionalInputClaimed();
-
-  static bool IsModifier(KeyCode key);
-
-  static bool IsModified();
-  static bool IsInputFocused();
-  static bool HasShift();
-  static bool HasAlt();
-  static bool HasCtrl();
-};
diff --git a/mods/src/patches/mapkey.cc b/mods/src/patches/mapkey.cc
deleted file mode 100644
index a3234eeba..000000000
--- a/mods/src/patches/mapkey.cc
+++ /dev/null
@@ -1,291 +0,0 @@
-#include "mapkey.h"
-#include "gamefunctions.h"
-#include "key.h"
-#include "modifierkey.h"
-#include "str_utils.h"
-#include <prime/KeyCode.h>
-
-#include <array>
-#include <iostream>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace
-{
-struct CompactShortcutTokenMapping {
-  std::string_view token;
-  std::string_view compact;
-  bool             primary_key_only = false;
-};
-
-// Use AutoHotkey's established ASCII modifier notation so the native game's limited font can render every badge.
-constexpr auto kCompactShortcutTokenMappings = std::to_array<CompactShortcutTokenMapping>({
-    {"SHIFT", "+"},
-    {"CTRL", "^"},
-    {"ALT", "!"},
-    {"ALTGR", "!"},
-    {"APPLE", "#"},
-    {"CMD", "#"},
-    {"WIN", "#"},
-    {"LSHIFT", "<+"},
-    {"RSHIFT", ">+"},
-    {"LCTRL", "<^"},
-    {"RCTRL", ">^"},
-    {"LALT", "<!"},
-    {"RALT", ">!"},
-    {"LAPPLE", "<#"},
-    {"LCOM", "<#"},
-    {"LWIN", "<#"},
-    {"RAPPLE", ">#"},
-    {"RCOM", ">#"},
-    {"RWIN", ">#"},
-    {"+", "PLS", true},
-    {"^", "CAR", true},
-    {"!", "EXC", true},
-    {"#", "HSH", true},
-    {"SPACE", "SPC"},
-    {"MOUSE0", "M0"},
-    {"MOUSE1", "M1"},
-    {"MOUSE2", "M2"},
-    {"MOUSE3", "M3"},
-    {"MOUSE4", "M4"},
-    {"MOUSE5", "M5"},
-    {"MOUSE6", "M6"},
-    {"ENTER", "ENT"},
-    {"RETURN", "ENT"},
-    {"ESCAPE", "ESC"},
-    {"TAB", "TAB"},
-    {"BACKSPACE", "BS"},
-    {"DELETE", "DEL"},
-    {"MINUS", "-"},
-    {"EQUAL", "="},
-    {"LEFT", "LT"},
-    {"RIGHT", "RT"},
-    {"UP", "UP"},
-    {"DOWN", "DN"},
-    {"PGUP", "PU"},
-    {"PGDOWN", "PD"},
-    {"HOME", "HM"},
-    {"END", "END"},
-});
-
-consteval bool CompactShortcutTokensAreUnique()
-{
-  for (size_t index = 0; index < kCompactShortcutTokenMappings.size(); ++index) {
-    for (size_t other = index + 1; other < kCompactShortcutTokenMappings.size(); ++other) {
-      if (kCompactShortcutTokenMappings[index].token == kCompactShortcutTokenMappings[other].token) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-static_assert(CompactShortcutTokensAreUnique());
-
-constexpr std::string_view CompactShortcutToken(std::string_view token, bool is_primary_key)
-{
-  for (const auto& mapping : kCompactShortcutTokenMappings) {
-    if (mapping.token == token && (!mapping.primary_key_only || is_primary_key)) {
-      return mapping.compact;
-    }
-  }
-  return token;
-}
-
-static_assert(CompactShortcutToken("CTRL", false) == "^");
-static_assert(CompactShortcutToken("ALTGR", false) == "!");
-static_assert(CompactShortcutToken("+", true) == "PLS");
-static_assert(CompactShortcutToken("+", false) == "+");
-static_assert(CompactShortcutToken("F7", true) == "F7");
-
-std::string CompactShortcutForHint(const std::vector<std::string>& shortcuts)
-{
-  std::string compact;
-  for (size_t index = 0; index < shortcuts.size(); ++index) {
-    compact.append(CompactShortcutToken(shortcuts[index], index + 1 == shortcuts.size()));
-  }
-  return compact;
-}
-} // namespace
-
-MapKey::MapKey()
-{
-  this->Key          = KeyCode::None;
-  this->hasModifiers = false;
-}
-
-MapKey MapKey::Parse(std::string_view key)
-{
-  auto strippedKey = StripTrailingAsciiWhitespace(key);
-  auto lowerKey    = AsciiStrToUpper(strippedKey);
-  auto wantedKeys  = StrSplit(lowerKey, '-');
-
-  MapKey mapKey;
-  for (std::string_view wantedKey : wantedKeys) {
-    auto modifier = ModifierKey::Parse(wantedKey);
-    if (modifier.HasModifiers()) {
-      mapKey.hasModifiers = true;
-      mapKey.Modifiers.emplace_back(std::move(modifier));
-      mapKey.Shortcuts.emplace_back(wantedKey);
-    } else {
-      auto parsedKey = Key::Parse(wantedKey);
-
-      if (Key::IsModifier(parsedKey)) {
-        continue;
-      }
-
-      if (parsedKey != KeyCode::None) {
-        mapKey.Key = parsedKey;
-        mapKey.Shortcuts.emplace_back(wantedKey);
-      }
-    }
-
-#ifndef NDEBUG
-    if (mapKey.Key == KeyCode::X) {
-      std::cout << "\n\n----------\nX key:\n" << mapKey.GetParsedValues() << "\n----------\n\n";
-    }
-#endif
-  }
-
-  return mapKey;
-}
-
-std::string MapKey::GetShortcuts(GameFunction gameFunction)
-{
-  const auto &mapKeys = MapKey::mappedKeys[gameFunction];
-
-  bool appendPipe = false;
-
-  std::string shortcuts = "";
-  for (const MapKey &mapKey : mapKeys) {
-    if (appendPipe) {
-      shortcuts.append(" | ");
-    }
-    shortcuts.append(mapKey.GetParsedValues());
-    appendPipe = true;
-  }
-
-  return shortcuts;
-}
-
-std::string MapKey::GetShortcutHint(GameFunction gameFunction)
-{
-  const auto& mapKeys = MapKey::mappedKeys[gameFunction];
-  return mapKeys.empty() ? "" : mapKeys.front().shortcutHint;
-}
-
-void MapKey::CacheShortcutHints()
-{
-  // Native badges display only the first binding for each action.
-  for (auto& mapKeys : mappedKeys) {
-    if (!mapKeys.empty()) {
-      mapKeys.front().shortcutHint = CompactShortcutForHint(mapKeys.front().Shortcuts);
-    }
-  }
-}
-
-bool MapKey::HasBinding(GameFunction gameFunction)
-{
-  for (const auto& mapKey : mappedKeys[gameFunction]) {
-    if (mapKey.Key != KeyCode::None) {
-      return true;
-    }
-  }
-  return false;
-}
-
-void MapKey::AddMappedKey(GameFunction gameFunction, MapKey mappedKey)
-{
-  MapKey::mappedKeys[gameFunction].emplace_back(std::move(mappedKey));
-}
-
-// Movement reads the direction itself; claiming it would suppress its own pan
-// on the next frame. Other modified actions retain ownership until key release.
-static bool IsMovementAction(GameFunction action)
-{
-  return action == GameFunction::MoveLeft || action == GameFunction::MoveRight
-         || action == GameFunction::MoveUp || action == GameFunction::MoveDown;
-}
-
-bool MapKey::IsPressed(GameFunction gameFunction)
-{
-  const auto &mapKeys = MapKey::mappedKeys[(int)gameFunction];
-  for (const MapKey &mapKey : mapKeys) {
-    if (mapKey.Key != KeyCode::None) {
-      if (Key::Pressed(mapKey.Key)) {
-        if (MapKey::HasCorrectModifiers(mapKey)) {
-          if (mapKey.hasModifiers && !IsMovementAction(gameFunction)) {
-            Key::ClaimDirectionalInput(mapKey.Key);
-          }
-          return true;
-        }
-      }
-    }
-  }
-
-  return false;
-}
-
-bool MapKey::IsDown(GameFunction gameFunction)
-{
-  const auto &mapKeys = MapKey::mappedKeys[(int)gameFunction];
-  for (const MapKey &mapKey : mapKeys) {
-    if (mapKey.Key != KeyCode::None) {
-      if (Key::Down(mapKey.Key)) {
-        if (MapKey::HasCorrectModifiers(mapKey)) {
-          if (mapKey.hasModifiers && !IsMovementAction(gameFunction)) {
-            Key::ClaimDirectionalInput(mapKey.Key);
-          }
-          return true;
-        }
-      }
-    }
-  }
-
-  return false;
-}
-
-bool MapKey::HasCorrectModifiers(const MapKey& mapKey)
-{
-  auto        result  = false;
-  std::string section = "non set";
-  if (!mapKey.hasModifiers) {
-    section = "no modifiers";
-    result  = !Key::IsModified();
-  } else {
-    result = true;
-    for (const ModifierKey& modifier : mapKey.Modifiers) {
-      if (!modifier.IsPressed()) {
-        section = modifier.GetParsedValues();
-        result  = false;
-        break;
-      }
-    }
-  }
-
-#ifndef NDEBUG
-  if (mapKey.Key == KeyCode::Backslash && Key::Pressed(KeyCode::Backslash)) {
-    std::cout << "HasCorrectModifiers(" << mapKey.GetParsedValues() << "): [" << section << "] " << result << "\n";
-  }
-#endif
-
-  return result;
-}
-
-std::string MapKey::GetParsedValues() const
-{
-  std::string output = "";
-  for (const std::string_view key : this->Shortcuts) {
-    if (output.length()) {
-      output.append("-");
-    }
-    output.append(key);
-  }
-
-  return output;
-}
-
-std::array<std::vector<MapKey>, (int)GameFunction::Max> MapKey::mappedKeys = {};
diff --git a/mods/src/patches/mapkey.h b/mods/src/patches/mapkey.h
deleted file mode 100644
index b5d73bedf..000000000
--- a/mods/src/patches/mapkey.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include "modifierkey.h"
-#include <patches/gamefunctions.h>
-#include <prime/KeyCode.h>
-
-#include <array>
-#include <string>
-#include <string_view>
-#include <vector>
-
-class MapKey
-{
-public:
-  MapKey();
-
-  static MapKey Parse(std::string_view key);
-  static void   AddMappedKey(GameFunction gameFunction, MapKey mappedKey);
-  static bool   HasBinding(GameFunction gameFunction);
-  static bool   IsPressed(GameFunction gameFunction);
-  static bool   IsDown(GameFunction gameFunction);
-  static bool   HasCorrectModifiers(const MapKey& mapKey);
-
-  static std::string GetShortcuts(GameFunction gameFunction);
-  static std::string GetShortcutHint(GameFunction gameFunction);
-  // Call once after config parsing, only when shortcut hints are enabled.
-  static void CacheShortcutHints();
-
-  std::string GetParsedValues() const;
-
-  std::vector<ModifierKey> Modifiers;
-  std::vector<std::string> Shortcuts;
-
-  KeyCode Key;
-
-private:
-  static std::array<std::vector<MapKey>, (int)GameFunction::Max> mappedKeys;
-
-  bool        hasModifiers;
-  std::string shortcutHint;
-};
diff --git a/mods/src/patches/modifierkey.cc b/mods/src/patches/modifierkey.cc
deleted file mode 100644
index d9205193e..000000000
--- a/mods/src/patches/modifierkey.cc
+++ /dev/null
@@ -1,115 +0,0 @@
-#include "config.h"
-#include "str_utils.h"
-#include "key.h"
-#include "modifierkey.h"
-
-#include <iostream>
-#include <string>
-#include <string_view>
-
-bool ModifierKey::HasModifiers() const
-{
-  return this->hasModifier;
-}
-
-ModifierKey::ModifierKey()
-{
-  this->hasModifier = false;
-}
-
-ModifierKey ModifierKey::Parse(std::string_view key)
-{
-  auto strippedKey = StripTrailingAsciiWhitespace(key);
-  auto upperKey    = AsciiStrToUpper(strippedKey);
-  auto wantedKeys  = StrSplit(upperKey, '-');
-
-  ModifierKey modifierKey;
-  for (std::string_view wantedKey : wantedKeys) {
-    if (wantedKey == "SHIFT") {
-      modifierKey.AddModifier(wantedKey, KeyCode::LeftShift, KeyCode::RightShift);
-    } else if (wantedKey == "ALT") {
-      modifierKey.AddModifier(wantedKey, KeyCode::LeftAlt, KeyCode::RightAlt);
-    } else if (wantedKey == "CTRL") {
-      modifierKey.AddModifier(wantedKey, KeyCode::LeftControl, KeyCode::RightControl);
-    } else if (wantedKey == "APPLE") {
-      modifierKey.AddModifier(wantedKey, KeyCode::LeftApple, KeyCode::RightApple);
-    } else if (wantedKey == "CMD") {
-      modifierKey.AddModifier(wantedKey, KeyCode::LeftCommand, KeyCode::RightCommand);
-    } else if (wantedKey == "WIN") {
-      modifierKey.AddModifier(wantedKey, KeyCode::LeftWindows, KeyCode::RightWindows);
-    } else {
-      auto parsedKey = Key::Parse(wantedKey);
-
-      if (Key::IsModifier(parsedKey)) {
-        modifierKey.AddModifier(wantedKey, parsedKey, KeyCode::None);
-      }
-    }
-  }
-
-  return modifierKey;
-}
-
-bool ModifierKey::Contains(KeyCode modifier) const
-{
-  if (this->hasModifier) {
-    return (std::find(this->Modifiers.begin(), this->Modifiers.end(), modifier) != this->Modifiers.end());
-  }
-
-  return false;
-}
-
-void ModifierKey::AddModifier(std::string_view shortcut, KeyCode modifier1, KeyCode modifier2)
-{
-  if (!this->Contains(modifier1)) {
-    this->hasModifier = true;
-    this->Modifiers.emplace_back(modifier1);
-    this->Shortcuts.emplace_back(shortcut);
-  }
-
-  if (!this->Contains(modifier2)) {
-    this->hasModifier = true;
-    this->Modifiers.emplace_back(modifier2);
-    this->Shortcuts.emplace_back(shortcut);
-  }
-}
-
-bool ModifierKey::IsPressed() const
-{
-  if (this->hasModifier) {
-    for (auto modifier : this->Modifiers) {
-      if (Key::Pressed(modifier)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-bool ModifierKey::IsDown() const
-{
-  if (this->hasModifier) {
-    for (auto modifier : this->Modifiers) {
-      if (Key::Down(modifier)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-std::string ModifierKey::GetParsedValues() const
-{
-  std::string output = "";
-  if (this->hasModifier) {
-    for (const std::string_view key : this->Shortcuts) {
-      if (output.length()) {
-        output.append("-");
-      }
-      output.append(key);
-    }
-  }
-
-  return output;
-}
diff --git a/mods/src/patches/modifierkey.h b/mods/src/patches/modifierkey.h
deleted file mode 100644
index a74587bca..000000000
--- a/mods/src/patches/modifierkey.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-
-#include <patches/gamefunctions.h>
-#include <prime/KeyCode.h>
-
-#include "key.h"
-
-#include <string>
-#include <vector>
-
-struct ModifierKey
-{
-public:
-  ModifierKey();
-
-  static ModifierKey Parse(std::string_view key);
-
-  void AddModifier(std::string_view shortcut, KeyCode modifier1, KeyCode modifier2);
-  bool Contains(KeyCode modifier) const;
-  bool IsPressed() const;
-  bool IsDown() const;
-  bool HasModifiers() const;
-
-  std::string GetParsedValues() const;
-
-private:
-  std::vector<KeyCode>     Modifiers;
-  std::vector<std::string> Shortcuts;
-  bool                     hasModifier;
-};
diff --git a/mods/src/patches/notification_service.cc b/mods/src/patches/notification_service.cc
deleted file mode 100644
index e4f796d18..000000000
--- a/mods/src/patches/notification_service.cc
+++ /dev/null
@@ -1,451 +0,0 @@
-#include "patches/notification_service.h"
-#include "patches/battle_notify_parser.h"
-
-#include "config.h"
-#include "str_utils.h"
-
-#include <il2cpp/il2cpp.h>
-#include <prime/LanguageManager.h>
-#include <prime/LocaleTextContext.h>
-#include <prime/Toast.h>
-
-#include <spdlog/spdlog.h>
-
-#include <string>
-
-#if _WIN32
-#include <windows.h>
-#include <winrt/Windows.Data.Xml.Dom.h>
-#include <winrt/Windows.UI.Notifications.h>
-#endif
-
-namespace {
-
-// EventCategories is a struct wrapping one int32 (_flagValue).
-struct EventCategories {
-  int32_t flagValue;
-};
-
-struct EventModel : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimePlatform.Models", "EventModel">;
-
-  EventCategories category()
-  { return Field<"category_", EventCategories>(); }
-};
-
-} // namespace
-
-// ---------------------------------------------------------------------------
-// Toast state → human-readable title
-// ---------------------------------------------------------------------------
-static const char* toast_state_title(int state)
-{
-  switch (state) {
-    case Standard:                  return "Notification";
-    case FactionWarning:            return "Faction Warning";
-    case FactionLevelUp:            return "Faction Level Up";
-    case FactionLevelDown:          return "Faction Level Down";
-    case FactionDiscovered:         return "Faction Discovered";
-    case IncomingAttack:            return "Incoming Attack!";
-    case IncomingAttackFaction:     return "Incoming Faction Attack!";
-    case FleetBattle:               return "Fleet Battle";
-    case StationBattle:             return "Station Under Attack!";
-    case StationVictory:            return "Station Victory!";
-    case Victory:                   return "Victory!";
-    case Defeat:                    return "Defeat";
-    case StationDefeat:             return "Station Defeat";
-    case Tournament:                return "Event Progress";
-    case ArmadaCreated:             return "Armada Created";
-    case ArmadaCanceled:            return "Armada Canceled";
-    case ArmadaIncomingAttack:      return "Armada Under Attack!";
-    case ArmadaBattleWon:           return "Armada Victory!";
-    case ArmadaBattleLost:          return "Armada Defeated";
-    case DiplomacyUpdated:          return "Diplomacy Updated";
-    case JoinedTakeover:            return "Territory Capture Joined";
-    case CompetitorJoinedTakeover:  return "Competitor Joined Territory";
-    case AbandonedTerritory:        return "Territory Abandoned";
-    case TakeoverVictory:           return "Takeover Victory!";
-    case TakeoverDefeat:            return "Takeover Defeat";
-    case TreasuryProgress:          return "Treasury Progress";
-    case TreasuryFull:              return "Treasury Full";
-    case Achievement:               return "Achievement";
-    case AssaultVictory:            return "Assault Victory!";
-    case AssaultDefeat:             return "Assault Defeat";
-    case ChallengeComplete:         return "Challenge Complete";
-    case ChallengeFailed:           return "Challenge Failed";
-    case StrikeHit:                 return "Strike Hit";
-    case StrikeDefeat:              return "Strike Defeat";
-    case WarchestProgress:          return "Warchest Progress";
-    case WarchestFull:              return "Warchest Full";
-    case PartialVictory:            return "Partial Victory";
-    case ArenaTimeLeft:             return "Arena Time Warning";
-    case ChainedEventScored:        return "Event Progress";
-    case FleetPresetApplied:        return "Fleet Preset Applied";
-    case SurgeWarmUpEnded:          return "Surge Started";
-    case SurgeHostileGroupDefeated: return "Surge Hostiles Defeated";
-    case SurgeTimeLeft:             return "Surge Time Warning";
-    case QueueForLeaseActivated:    return "Queue Activated";
-    case QueueForLeaseExpired:      return "Queue Expired";
-    case PermanentQueuePurchased:   return "Permanent Queue Purchased";
-    case OutpostStartedOrEnded:     return "Outpost Update";
-    case CrossAllianceArmadaVictory:      return "Cross-Armada Victory!";
-    case CrossAllianceArmadaDefeat:       return "Cross-Armada Defeated";
-    case CrossAllianceArmadaPartialVictory: return "Cross-Armada Partial Victory";
-    case FactionWeeklyEventsProgress:     return "Faction Weekly Event Progress";
-    case FactionWeeklyEventsComplete:     return "Faction Weekly Event Complete";
-    case ArmadaPlayerBlocked:       return "Armada Player Blocked";
-    case ArmadaPlayerUnblocked:     return "Armada Player Unblocked";
-    case DynamicCrisisUpdate:       return "Dynamic Crisis Update";
-    case DynamicCrisisFailed:       return "Dynamic Crisis Failed";
-    case DynamicCrisisCompleted:    return "Dynamic Crisis Completed";
-    case GalacticAnomalySystemEntered: return "Galactic Anomaly Entered";
-    default:                        return nullptr;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Platform notification delivery
-// ---------------------------------------------------------------------------
-#if _WIN32
-static void show_system_notification(const char* title, const char* body)
-{
-  try {
-    using namespace winrt::Windows::UI::Notifications;
-    using namespace winrt::Windows::Data::Xml::Dom;
-
-    auto xml   = ToastNotificationManager::GetTemplateContent(ToastTemplateType::ToastText02);
-    auto nodes = xml.GetElementsByTagName(L"text");
-    nodes.Item(0).InnerText(winrt::to_hstring(title));
-    nodes.Item(1).InnerText(winrt::to_hstring(body));
-
-    auto notification = ToastNotification(xml);
-    auto notifier     = ToastNotificationManager::CreateToastNotifier(L"Star Trek Fleet Command");
-    notifier.Show(notification);
-  } catch (const winrt::hresult_error& e) {
-    spdlog::warn("[Notify] WinRT notification failed: {}", winrt::to_string(e.message()));
-  } catch (...) {
-    spdlog::warn("[Notify] WinRT notification failed (unknown error)");
-  }
-}
-#endif
-
-// ---------------------------------------------------------------------------
-// SEH wrapper — catches access violations from bad IL2CPP pointers
-// ---------------------------------------------------------------------------
-template <typename Fn>
-static bool seh_call(Fn fn)
-{
-#if _WIN32
-  __try {
-    fn();
-    return true;
-  } __except (EXCEPTION_EXECUTE_HANDLER) {
-    return false;
-  }
-#else
-  fn();
-  return true;
-#endif
-}
-
-// ---------------------------------------------------------------------------
-// SEH-protected object to string conversion
-// ---------------------------------------------------------------------------
-static Il2CppString* seh_to_string_raw(Il2CppObject* obj)
-{
-  auto* cls = il2cpp_object_get_class(obj);
-  if (cls) {
-    auto* name = il2cpp_class_get_name(cls);
-    if (name && strcmp(name, "String") == 0)
-      return reinterpret_cast<Il2CppString*>(obj);
-  }
-  // Virtual ToString(); boxed value types dispatch to their own override.
-  return static_cast<il2cpp::Object*>(obj)->Call<"ToString", Il2CppString*>();
-}
-
-static std::string safe_il2cpp_to_string(Il2CppObject* obj, il2cpp_array_size_t index)
-{
-  Il2CppString* raw = nullptr;
-  if (!seh_call([&] { raw = seh_to_string_raw(obj); })) {
-    spdlog::warn("[Notify] SEH: ToString crashed for param {}", index);
-    return {};
-  }
-  if (!raw) return {};
-  return to_string(raw);
-}
-
-// ---------------------------------------------------------------------------
-// Replace {N} placeholders in template with values from an IL2CPP object[]
-// ---------------------------------------------------------------------------
-static std::string format_with_array(const std::string& tmpl, il2cpp::Array<Il2CppObject*>* arr)
-{
-  if (!arr) return tmpl;
-
-  auto len = arr->size();
-  if (len == 0) return tmpl;
-
-  std::string result = tmpl;
-  for (il2cpp_array_size_t i = 0; i < len; ++i) {
-    auto* elem = (*arr)[i];
-    if (!elem) continue;
-
-    auto val = safe_il2cpp_to_string(elem, i);
-    if (val.empty()) continue;
-
-    auto prefix = "{" + std::to_string(i);
-    for (auto pos = result.find(prefix); pos != std::string::npos; pos = result.find(prefix, pos + val.size())) {
-      auto suffix = pos + prefix.size();
-      auto end    = result.find('}', suffix);
-      if (end == std::string::npos) break;
-
-      // Accept both {N} and the numeric zero-padding form used by toast
-      // templates, for example {5:000}.
-      auto replacement = val;
-      if (suffix != end) {
-        if (result[suffix] != ':') continue;
-        auto format = result.substr(suffix + 1, end - suffix - 1);
-        if (!format.empty() && format.find_first_not_of('0') == std::string::npos && replacement.size() < format.size())
-          replacement.insert(0, format.size() - replacement.size(), '0');
-      }
-
-      result.replace(pos, end - pos + 1, replacement);
-    }
-  }
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Try every instance array field on an object. Toast parameter arrays have
-// moved and changed names between game builds, including generated backing
-// fields, so runtime metadata is more reliable than names or offsets. This
-// scan stays on the raw field API because no member name is known up front.
-// ---------------------------------------------------------------------------
-static std::string format_with_array_fields(const std::string& tmpl, Il2CppObject* obj, std::string& fields_seen)
-{
-  if (!obj) return tmpl;
-
-  auto result = tmpl;
-  for (auto* cls = il2cpp_object_get_class(obj); cls; cls = il2cpp_class_get_parent(cls)) {
-    void* iter = nullptr;
-    while (auto* field = il2cpp_class_get_fields(cls, &iter)) {
-      if ((il2cpp_field_get_flags(field) & FIELD_ATTRIBUTE_STATIC) != 0) continue;
-
-      auto* type = il2cpp_field_get_type(field);
-      auto  kind = type ? il2cpp_type_get_type(type) : IL2CPP_TYPE_END;
-      if (kind != IL2CPP_TYPE_SZARRAY && kind != IL2CPP_TYPE_ARRAY) continue;
-
-      il2cpp::Array<Il2CppObject*>* arr = nullptr;
-      il2cpp_field_get_value(obj, field, &arr);
-
-      if (!fields_seen.empty()) fields_seen += ", ";
-      fields_seen += il2cpp_field_get_name(field);
-      fields_seen += arr ? "[" + std::to_string(arr->size()) + "]" : "[null]";
-
-      if (!arr || arr->size() == 0) continue;
-      auto candidate = format_with_array(tmpl, arr);
-      if (std::ranges::count(candidate, '{') < std::ranges::count(result, '{'))
-        result = std::move(candidate);
-    }
-  }
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Replace {N} placeholders using Toast.TextParameters, falling back to
-// LocaleTextContext._textParameters if the Toast array is empty.
-// ---------------------------------------------------------------------------
-static std::string format_placeholders(const std::string& tmpl, Toast* toast, LocaleTextContext* ltc)
-{
-  // Try Toast.TextParameters first.
-  auto* toast_arr = toast->get_TextParameters();
-  if (toast_arr && toast_arr->size() > 0) {
-    return format_with_array(tmpl, toast_arr);
-  }
-
-  std::string fields_seen;
-  auto result = format_with_array_fields(tmpl, toast, fields_seen);
-  if (result != tmpl) return result;
-
-  result = format_with_array_fields(tmpl, ltc, fields_seen);
-  if (result != tmpl) return result;
-
-  if (tmpl.find('{') != std::string::npos) {
-    spdlog::warn("[Notify] Placeholders unresolved; array fields seen: {}. Template: \"{}\"",
-                 fields_seen.empty() ? "none" : fields_seen, tmpl);
-  }
-  return tmpl;
-}
-
-// ---------------------------------------------------------------------------
-// Resolve basic localized text from a Toast's TextLocaleTextContext
-// ---------------------------------------------------------------------------
-static std::string resolve_toast_text(Toast* toast)
-{
-  auto* ltc = static_cast<LocaleTextContext*>(toast->get_TextLocaleTextContext());
-  if (!ltc) {
-    spdlog::debug("[Notify] No TextLocaleTextContext for toast state {}", toast->get_State());
-    return {};
-  }
-
-  // Try the static LocaleUtilities.Localize(LTC, bool, bool) first — it handles
-  // parameter substitution internally and returns a fully formatted string.
-  if (auto* ret = LocaleUtilities::Localize(ltc, true, false)) {
-    auto result = to_string(ret);
-    // LocaleUtilities.Localize may return a template with unresolved {N}
-    // placeholders if the LTC's own _textParameters are empty.  The actual
-    // parameter values may be in Toast.TextParameters, so run
-    // format_placeholders to substitute them.
-    if (result.find('{') != std::string::npos)
-      result = format_placeholders(result, toast, ltc);
-    return result;
-  }
-  spdlog::debug("[Notify] LocaleUtilities.Localize returned null for toast state {}", toast->get_State());
-
-  // Fall back to instance LanguageManager.Localize(out string, LTC)
-  auto* langMgr = LanguageManager::Instance();
-  if (!langMgr) return {};
-
-  Il2CppString* resolved = nullptr;
-  if (!langMgr->Localize(resolved, ltc) || !resolved) {
-    spdlog::debug("[Notify] LanguageManager.Localize returned false for toast state {}", toast->get_State());
-    return {};
-  }
-
-  auto tmpl = to_string(resolved);
-  return format_placeholders(tmpl, toast, ltc);
-}
-
-// ---------------------------------------------------------------------------
-// Resolve the event category from Toast.Data (EventModel.category_) and map
-// it to a human-readable name.
-// ---------------------------------------------------------------------------
-static const char* event_category_name(int32_t cat)
-{
-  switch (cat) {
-    case 0:  return "Standard";
-    case 1:  return "Daily Goals";
-    case 2:  return "Daily Milestone";
-    case 3:  return "Leaderboard";
-    case 4:  return "Stat";
-    case 5:  return "Battle Pass Season";
-    case 6:  return "Battle Pass Event";
-    case 7:  return "Treasury Progress";
-    case 8:  return "Treasury Reward";
-    case 9:  return "Server Clash";
-    case 10: return "Webstore Event";
-    case 11: return "Player Lifecycle";
-    case 12: return "Field Training";
-    case 13: return "FT Category";
-    case 14: return "Cutscenes";
-    case 15: return "Minigame";
-    case 16: return "Minigame Stage";
-    case 17: return "Warchest";
-    case 18: return "Alliance Game";
-    case 19: return "Alliance Game Task";
-    case 20: return "Meta Event";
-    case 21: return "Meta Event Objective";
-    case 22: return "Invasion";
-    case 23: return "Loop Museum";
-    case 24: return "Loop Museum Task";
-    case 25: return "PLC BP Season";
-    case 26: return "PLC BP Event";
-    case 27: return "Progression Reward";
-    case 28: return "Faction Weekly Events";
-    default: return nullptr;
-  }
-}
-
-static std::string resolve_event_category(Toast* toast)
-{
-  auto* data = toast->get_Data();
-  auto* event = data ? static_cast<il2cpp::Object*>(data)->As<EventModel>() : nullptr;
-  if (!event) return {};
-
-  auto* name = event_category_name(event->category().flagValue);
-  return name ? name : std::string{};
-}
-
-// ---------------------------------------------------------------------------
-// Strip Unity rich text tags (e.g. <color=#FF0000>, <b>, </size>)
-// ---------------------------------------------------------------------------
-static std::string strip_unity_rich_text(const std::string& s)
-{
-  std::string result;
-  result.reserve(s.size());
-  size_t i = 0;
-  while (i < s.size()) {
-    if (s[i] == '<') {
-      auto end = s.find('>', i);
-      if (end != std::string::npos) { i = end + 1; continue; }
-    }
-    result += s[i++];
-  }
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-void notification_init()
-{
-  // IL2CPP members resolve on first use; only the platform side needs setup.
-#if _WIN32
-  try {
-    winrt::init_apartment(winrt::apartment_type::single_threaded);
-    spdlog::info("[Notify] Windows notification service initialized");
-  } catch (const winrt::hresult_error& e) {
-    spdlog::warn("[Notify] Windows notification service failed: {:#x} {}",
-                 static_cast<unsigned long>(e.code()), winrt::to_string(e.message()));
-  } catch (...) {
-    spdlog::warn("[Notify] Windows notification service failed (unknown error)");
-  }
-#else
-  spdlog::info("[Notify] Notification service: platform not supported (no-op)");
-#endif
-}
-
-void notification_handle_toast(Toast* toast)
-{
-  if (!toast)
-    return;
-  notification_audio_play(Config::Get().NotificationSoundForToast(static_cast<int>(toast->get_State())));
-#if !_WIN32
-  return; // No notification delivery on non-Windows platforms yet
-#else
-  auto state = toast->get_State();
-
-  // Check if this toast type is in the user's notify list
-  const auto& notify_types = Config::Get().notify_banner_types;
-  if (std::ranges::find(notify_types, state) == notify_types.end()) {
-    return;
-  }
-
-  auto* title = toast_state_title(state);
-  if (!title) {
-    spdlog::debug("[Notify] No title mapping for toast state {}, skipping", state);
-    return;
-  }
-
-  auto body = battle_notify_parse(toast);
-  if (body.empty()) {
-    body = strip_unity_rich_text(resolve_toast_text(toast));
-  }
-  if (body.empty()) {
-    body = "(no details available)";
-  }
-
-  // Prepend event category for event-based toasts that use EventModel as Data
-  if (state == Achievement || state == Tournament || state == ChainedEventScored ||
-      state == TreasuryProgress || state == TreasuryFull ||
-      state == WarchestProgress || state == WarchestFull ||
-      state == FactionWeeklyEventsProgress || state == FactionWeeklyEventsComplete) {
-    auto category = resolve_event_category(toast);
-    if (!category.empty()) {
-      body = category + " - " + body;
-    }
-  }
-
-  show_system_notification(title, body.c_str());
-#endif
-}
diff --git a/mods/src/patches/notification_service.h b/mods/src/patches/notification_service.h
deleted file mode 100644
index f848c5492..000000000
--- a/mods/src/patches/notification_service.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-struct Toast;
-
-// Initialize the notification platform (WinRT on Windows).
-// Call once during InstallToastBannerHooks().
-void notification_init();
-
-// Called from toast hooks — checks config, formats, and delivers notification.
-void notification_handle_toast(Toast* toast);
diff --git a/mods/src/patches/object_tracker.h b/mods/src/patches/object_tracker.h
deleted file mode 100644
index 5db105514..000000000
--- a/mods/src/patches/object_tracker.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-#include <EASTL/span.h>
-#include <EASTL/unordered_map.h>
-#include <EASTL/vector.h>
-
-// Game objects registered by the mod's Unity lifecycle hooks. These are borrowed pointers.
-extern eastl::unordered_map<Il2CppClass*, eastl::vector<uintptr_t>> tracked_objects;
-
-template <typename T> class ObjectFinder
-{
-public:
-  static T* Get()
-  {
-    auto& objects = tracked_objects[T::Class::Raw()];
-    if (objects.empty()) {
-      // TODO: assert?
-      return nullptr;
-    }
-    return reinterpret_cast<T*>(objects.back());
-  }
-
-  static eastl::span<T*> GetAll()
-  {
-    auto& objects = tracked_objects[T::Class::Raw()];
-    return {reinterpret_cast<T**>(objects.data()), reinterpret_cast<T**>(objects.data()) + objects.size()};
-  }
-};
diff --git a/mods/src/patches/parts/action_queue.cc b/mods/src/patches/parts/action_queue.cc
index cc2b0cbab..ccbd516a7 100644
--- a/mods/src/patches/parts/action_queue.cc
+++ b/mods/src/patches/parts/action_queue.cc
@@ -1,136 +1,45 @@
 #include "action_queue.h"
+#include "patches/patches.h"
 #include <config.h>
 
 // Use the host ABI for the 24-byte value-type callback on Windows and both Mac architectures.
 // Validate the managed layout before installing.
-#include <atomic>
+#include "prime/queues.h"
 #include <array>
-#include <utility>
+#include <atomic>
 #include <cstring>
-#include <il2cpp/il2cpp_helper.h>
-#include <il2cpp/method_contract.h>
+#include <il2cpp/hook.h>
 #include <mutex>
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
+#include <utility>
+
+using namespace queue_bindings::recovery;
 
 namespace
 {
 using action_queue::Clock;
 using action_queue::QueueState;
-struct WeakQueues {
-  using Object = Il2CppObject*;
-  using Handle = Il2CppGCHandle;
-  static Handle New(Object value)
-  { return il2cpp_gchandle_new_weakref(value, false); }
-  static Object Get(Handle handle)
-  { return il2cpp_gchandle_get_target(handle); }
-  static void Free(Handle handle)
-  { il2cpp_gchandle_free(handle); }
-};
 action_queue::Requests<WeakQueues> requests;
 std::mutex                         requestsMutex;
 std::atomic_bool                   ready{false};
-Il2CppClass *                      queueClass{}, *actionClass{}, *int64Class{};
 
 bool Enabled()
-{ return ready.load() && Config::Get().kirshara_fixes && Config::Get().queue_enabled; }
+{ return ready.load() && Config::Get().control.kirshara_fixes && Config::Get().control.queue_enabled; }
 void ClearRequests()
 {
   std::lock_guard lock(requestsMutex);
   requests.Clear();
 }
-template <typename T> T Read(const void* object, std::size_t offset)
-{
-  T value{};
-  if (object)
-    std::memcpy(&value, static_cast<const char*>(object) + offset, sizeof(value));
-  return value;
-}
-// Inspect actual List<QueueableAction> storage without invoking game properties or enumerators.
-// Unknown storage/layout is ineligible, never equivalent to an empty queue or absent target.
-QueueState Inspect(Il2CppObject* queue, std::int64_t target = 0)
-{
-  QueueState s;
-  if (!queue || il2cpp_object_get_class(queue) != queueClass)
-    return s;
-  s.fleet    = Read<std::int64_t>(queue, 0x30);
-  s.attempt  = Read<float>(queue, 0x14);
-  s.engaging = Read<bool>(queue, 0x10);
-  auto* list = Read<Il2CppObject*>(queue, 0x28);
-  if (!list)
-    return s;
-  auto* cls     = il2cpp_object_get_class(list);
-  auto* size    = il2cpp_class_get_field_from_name(cls, "_size");
-  auto* storage = il2cpp_class_get_field_from_name(cls, "_items");
-  if (!size || !storage || !size->type || !storage->type || size->type->type != IL2CPP_TYPE_I4
-      || storage->type->type != IL2CPP_TYPE_SZARRAY || size->type->byref || storage->type->byref
-      || (il2cpp_field_get_flags(size) & FIELD_ATTRIBUTE_STATIC)
-      || (il2cpp_field_get_flags(storage) & FIELD_ATTRIBUTE_STATIC))
-    return s;
-  Il2CppArray* items{};
-  il2cpp_field_get_value(list, size, &s.count);
-  il2cpp_field_get_value(list, storage, &items);
-  if (s.count < 0 || s.count > 128 || !items || il2cpp_array_length(items) < static_cast<unsigned>(s.count)
-      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Il2CppObject*>(items))) != actionClass)
-    return s;
-  auto*      array        = reinterpret_cast<Il2CppArraySize*>(items);
-  const auto inspectCount = target ? s.count : (s.count > 0 ? 1 : 0);
-  for (int i = 0; i < inspectCount; ++i) {
-    auto* action = static_cast<Il2CppObject*>(array->vector[i]);
-    if (!action || il2cpp_object_get_class(action) != actionClass)
-      return s;
-    const auto id = Read<std::int64_t>(action, 0x10);
-    if (i == 0)
-      s.front = id;
-    if (target && id == target)
-      s.containsTarget = true;
-  }
-  s.valid = s.fleet != 0;
-  return s;
-}
-Il2CppArraySize* Queues(Il2CppObject* manager)
-{
-  auto* array = Read<Il2CppArray*>(manager, 0x48);
-  if (!array || il2cpp_array_length(array) > 64
-      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Il2CppObject*>(array))) != queueClass)
-    return nullptr;
-  return reinterpret_cast<Il2CppArraySize*>(array);
-}
-Il2CppObject* FindQueue(Il2CppObject* manager, std::int64_t fleet)
-{
-  auto* array = Queues(manager);
-  if (!array)
-    return nullptr;
-  for (unsigned i = 0; i < array->max_length; ++i) {
-    auto* queue = static_cast<Il2CppObject*>(array->vector[i]);
-    if (queue && il2cpp_object_get_class(queue) == queueClass && Read<std::int64_t>(queue, 0x30) == fleet)
-      return queue;
-  }
-  return nullptr;
-}
-bool AbsentFromAllQueues(Il2CppObject* manager, std::int64_t target)
-{
-  auto* array = Queues(manager);
-  if (!array)
-    return false;
-  for (unsigned i = 0; i < array->max_length; ++i) {
-    auto* queue = static_cast<Il2CppObject*>(array->vector[i]);
-    if (!queue)
-      continue;
-    const auto s = Inspect(queue, target);
-    if (!s.valid || s.containsTarget)
-      return false;
-  }
-  return true;
-}
 struct CourseContext {
   std::int64_t  fleet{}, target{};
-  Il2CppObject* queue{}; // Borrowed only inside the synchronous native Course call.
-  bool          outstandingAtEntry{};
+  Il2CppObject* queue{}; // Borrowed only inside the synchronous native
+                         // ActionQueueManager_OnSetCourseResponseEventHandler_Hook call.
+  bool outstandingAtEntry{};
 };
 thread_local CourseContext* currentCourse{};
 
-int Engage(auto original, Il2CppObject* manager, Il2CppObject* player, Il2CppObject* queue)
+int ActionQueueManager_TryPlanPathAndEngageTarget_Hook(auto original, Il2CppObject* manager, Il2CppObject* player,
+                                                       Il2CppObject* queue)
 {
   std::uint64_t serial{};
   if (Enabled()) {
@@ -152,7 +61,8 @@ int Engage(auto original, Il2CppObject* manager, Il2CppObject* player, Il2CppObj
   }
   return result;
 }
-bool Retry(auto original, Il2CppObject* manager, std::int64_t target, Il2CppObject* queue)
+bool ActionQueueManager_ShouldRetryFailedSetCourse_Hook(auto original, Il2CppObject* manager, std::int64_t target,
+                                                        Il2CppObject* queue)
 {
   if (!Enabled())
     ClearRequests();
@@ -172,29 +82,22 @@ bool Retry(auto original, Il2CppObject* manager, std::int64_t target, Il2CppObje
     std::lock_guard lock(requestsMutex);
     if (!requests.Consume(queue, s, target, Clock::now()))
       return retry;
-    // The enclosing Course handler's true branch calls its normal planner for this same fleet.
-    // That planner retains all eligibility checks. No flags, targets or retry counters are changed here.
+    // The enclosing ActionQueueManager_OnSetCourseResponseEventHandler_Hook handler's true branch calls its normal
+    // planner for this same fleet. That planner retains all eligibility checks. No flags, targets or retry counters are
+    // changed here.
     return true;
   } catch (...) {
     return retry;
   }
 }
-struct CourseResponse {
-  std::int64_t  fleet;
-  bool          success, recall;
-  unsigned char padding[6];
-  Il2CppObject* target;
-};
-static_assert(sizeof(CourseResponse) == 24 && offsetof(CourseResponse, target) == 16);
-void Course(auto original, Il2CppObject* manager, CourseResponse args)
+void ActionQueueManager_OnSetCourseResponseEventHandler_Hook(auto original, Il2CppObject* manager, CourseResponse args)
 {
   if (!Enabled())
     ClearRequests();
   CourseContext context{args.fleet};
   if (Enabled() && !args.success && !args.recall) {
     try {
-      if (args.target && il2cpp_object_get_class(args.target) == int64Class) {
-        std::memcpy(&context.target, il2cpp_object_unbox(args.target), sizeof(context.target));
+      if (ReadCourseTarget(args.target, context.target)) {
         context.queue              = FindQueue(manager, args.fleet);
         context.outstandingAtEntry = context.queue && Read<bool>(context.queue, 0x10);
       }
@@ -211,117 +114,46 @@ void Course(auto original, Il2CppObject* manager, CourseResponse args)
   } scope(&context);
   original(manager, args);
 }
-void ClearAll(auto original, Il2CppObject* manager)
+void ActionQueueManager_StopWatchdogAndClearAllQueues_Hook(auto original, Il2CppObject* manager)
 {
   // Native session end/invalidation/quit share this seam; release weak handles while IL2CPP is alive.
   ClearRequests();
   original(manager);
 }
-bool Field(Il2CppClass* cls, const char* name, std::ptrdiff_t offset, Il2CppTypeEnum type)
-{
-  auto* field = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
-  const bool valid = field && field->offset == offset && field->type && !field->type->byref
-                     && !(il2cpp_field_get_flags(field) & FIELD_ATTRIBUTE_STATIC) && field->type->type == type;
-  if (!valid)
-    spdlog::warn("[FasterQueueRecovery] {}.{}: expected instance field offset=0x{:X} type={}; "
-                   "actual offset={} type={} static={} byref={}",
-                   cls ? cls->name : "<missing class>", name, offset, static_cast<int>(type),
-                   field ? field->offset : -1, field && field->type ? static_cast<int>(field->type->type) : -1,
-                   field && field->type && bool(il2cpp_field_get_flags(field) & FIELD_ATTRIBUTE_STATIC),
-                   field && field->type && bool(field->type->byref));
-  return valid;
-}
+
 } // namespace
 
 void ResetQueueRecoveryTracking()
 { ClearRequests(); }
 
+namespace
+{
 void InstallActionQueueRecovery()
 {
-  auto* cls   = il2cpp_get_class_helper("Assembly-CSharp", "Prime.ActionQueue", "ActionQueueManager").get_cls();
-  queueClass  = il2cpp_get_class_helper("Assembly-CSharp", "Prime.ActionQueue", "ActionQueueInstance").get_cls();
-  actionClass = il2cpp_get_class_helper("Assembly-CSharp", "Prime.ActionQueue", "QueueableAction").get_cls();
-  int64Class  = il2cpp_get_class_helper("mscorlib", "System", "Int64").get_cls();
-  if (!cls || !queueClass || !actionClass || !int64Class) {
-    for (const auto& [type, name] : std::array{
-             std::pair{cls, "Prime.ActionQueue.ActionQueueManager"},
-             std::pair{queueClass, "Prime.ActionQueue.ActionQueueInstance"},
-             std::pair{actionClass, "Prime.ActionQueue.QueueableAction"}, std::pair{int64Class, "System.Int64"}})
-      if (!type) spdlog::warn("[FasterQueueRecovery] unavailable: missing class {}", name);
-    return;
-  }
-  using method_contract::Resolve;
-  using method_contract::Pointer;
-  const auto* engage_info = Resolve(cls, "TryPlanPathAndEngageTarget", false, "Digit.Prime.Combat.EngageResult",
-      {"Digit.PrimeServer.Models.FleetPlayerData", "Prime.ActionQueue.ActionQueueInstance"});
-  auto* engage = Pointer(engage_info);
-  const auto* retry_info = Resolve(cls, "ShouldRetryFailedSetCourse", false, "System.Boolean",
-      {"System.Int64", "Prime.ActionQueue.ActionQueueInstance"});
-  auto* retry = Pointer(retry_info);
-  const auto* clear_info = Resolve(cls, "StopWatchdogAndClearAllQueues", false, "System.Void", {});
-  auto* clear = Pointer(clear_info);
-  const auto* info = Resolve(cls, "OnSetCourseResponseEventHandler", false, "System.Void",
-      {"Digit.PrimeServer.Events.SetCourseResponseEventArgs"});
-  auto* course = Pointer(info);
-  auto* event = info ? il2cpp_class_from_type(info->parameters[0]) : nullptr;
-  auto* result = engage_info ? il2cpp_class_from_type(engage_info->return_type) : nullptr;
-  const auto* underlying = result && il2cpp_class_is_enum(result) ? il2cpp_class_enum_basetype(result) : nullptr;
-  std::uint32_t alignment{};
-  const bool    valid =
-      underlying && underlying->type == IL2CPP_TYPE_I4
-      && event && info->parameters[0]->type == IL2CPP_TYPE_VALUETYPE
-      && il2cpp_class_value_size(event, &alignment) == sizeof(CourseResponse)
-      && Field(event, "<FleetId>k__BackingField", 0x10, IL2CPP_TYPE_I8)
-      && Field(event, "<Success>k__BackingField", 0x18, IL2CPP_TYPE_BOOLEAN)
-      && Field(event, "<IsRecall>k__BackingField", 0x19, IL2CPP_TYPE_BOOLEAN)
-      && Field(event, "<TargetId>k__BackingField", 0x20, IL2CPP_TYPE_OBJECT)
-      && Field(cls, "_battleQueue", 0x48, IL2CPP_TYPE_SZARRAY)
-      && Field(queueClass, "IsEngaging", 0x10, IL2CPP_TYPE_BOOLEAN)
-      && Field(queueClass, "LastEngageAttemptTime", 0x14, IL2CPP_TYPE_R4)
-      && Field(queueClass, "<PlayerFleetId>k__BackingField", 0x30, IL2CPP_TYPE_I8)
-      && Field(queueClass, "_actionQueue", 0x28, IL2CPP_TYPE_GENERICINST)
-      && Field(actionClass, "<FleetId>k__BackingField", 0x10, IL2CPP_TYPE_I8)
-      && engage && retry && course && clear
-      && !engage_info->has_full_generic_sharing_signature && !retry_info->has_full_generic_sharing_signature
-      && !info->has_full_generic_sharing_signature && !clear_info->has_full_generic_sharing_signature
-      && engage != retry && engage != course && engage != clear
-      && retry != course && retry != clear && course != clear;
-  if (!valid) {
-    const std::array methods{
-        std::pair{engage_info, "ActionQueueManager.TryPlanPathAndEngageTarget(FleetPlayerData, ActionQueueInstance) -> EngageResult"},
-        std::pair{retry_info, "ActionQueueManager.ShouldRetryFailedSetCourse(Int64, ActionQueueInstance) -> Boolean"},
-        std::pair{info, "ActionQueueManager.OnSetCourseResponseEventHandler(SetCourseResponseEventArgs) -> Void"},
-        std::pair{clear_info, "ActionQueueManager.StopWatchdogAndClearAllQueues() -> Void"}};
-    for (const auto& [method, name] : methods)
-      if (!method || !method->methodPointer || method->has_full_generic_sharing_signature)
-        spdlog::warn("[FasterQueueRecovery] unavailable: {}: {}", name,
-                       method && method->has_full_generic_sharing_signature ? "unsupported generic sharing"
-                                                                           : "instance method unavailable");
-    if (!underlying || underlying->type != IL2CPP_TYPE_I4)
-      spdlog::warn("[FasterQueueRecovery] unavailable: EngageResult must be an Int32 enum");
-    const auto event_size = event && info->parameters[0]->type == IL2CPP_TYPE_VALUETYPE
-                                ? il2cpp_class_value_size(event, &alignment) : -1;
-    if (event_size != sizeof(CourseResponse))
-      spdlog::warn("[FasterQueueRecovery] unavailable: SetCourseResponseEventArgs expected value type size={}; actual={}",
-                     sizeof(CourseResponse), event_size);
-    for (size_t i = 0; i < methods.size(); ++i)
-      for (size_t j = 0; j < i; ++j)
-        if (methods[i].first && methods[j].first && methods[i].first->methodPointer
-            && methods[i].first->methodPointer == methods[j].first->methodPointer)
-          spdlog::warn("[FasterQueueRecovery] unavailable: {} and {} share a native hook target",
-                         methods[i].second, methods[j].second);
+  if (!ResolveBindings())
     return;
-  }
-  const bool a = SPUD_STATIC_DETOUR(engage, Engage) != nullptr;
-  const bool b = SPUD_STATIC_DETOUR(retry, Retry) != nullptr;
-  const bool c = SPUD_STATIC_DETOUR(course, Course) != nullptr;
-  const bool d = SPUD_STATIC_DETOUR(clear, ClearAll) != nullptr;
-  for (const auto& [installed, name] : std::array{
-           std::pair{a, "ActionQueueManager.TryPlanPathAndEngageTarget"},
-           std::pair{b, "ActionQueueManager.ShouldRetryFailedSetCourse"},
-           std::pair{c, "ActionQueueManager.OnSetCourseResponseEventHandler"},
-           std::pair{d, "ActionQueueManager.StopWatchdogAndClearAllQueues"}})
-    if (!installed) spdlog::warn("[FasterQueueRecovery] hook installation failed: {}; feature unavailable", name);
+  const bool a = IL2CPP_DETOUR(engage, ActionQueueManager_TryPlanPathAndEngageTarget_Hook,
+                               "ActionQueueManager_TryPlanPathAndEngageTarget_Hook")
+                 != nullptr;
+  const bool b = IL2CPP_DETOUR(retry, ActionQueueManager_ShouldRetryFailedSetCourse_Hook,
+                               "ActionQueueManager_ShouldRetryFailedSetCourse_Hook")
+                 != nullptr;
+  const bool c = IL2CPP_DETOUR(course, ActionQueueManager_OnSetCourseResponseEventHandler_Hook,
+                               "ActionQueueManager_OnSetCourseResponseEventHandler_Hook")
+                 != nullptr;
+  const bool d = IL2CPP_DETOUR(clear, ActionQueueManager_StopWatchdogAndClearAllQueues_Hook,
+                               "ActionQueueManager_StopWatchdogAndClearAllQueues_Hook")
+                 != nullptr;
+  for (const auto& [installed, name] : std::array{std::pair{a, "ActionQueueManager.TryPlanPathAndEngageTarget"},
+                                                  std::pair{b, "ActionQueueManager.ShouldRetryFailedSetCourse"},
+                                                  std::pair{c, "ActionQueueManager.OnSetCourseResponseEventHandler"},
+                                                  std::pair{d, "ActionQueueManager.StopWatchdogAndClearAllQueues"}})
+    if (!installed)
+      spdlog::warn("[FasterQueueRecovery] hook installation failed: {}; feature unavailable", name);
   ready.store(a && b && c && d);
   spdlog::info("[FasterQueueRecovery] ready={}", ready.load());
 }
+} // namespace
+
+const Feature kActionQueueRecovery{"ActionQueueRecovery", &Config::Patches::actionqueuerecoveryhooks,
+                                   InstallActionQueueRecovery};
diff --git a/mods/src/patches/parts/alliance_store.cc b/mods/src/patches/parts/alliance_store.cc
index cdcec5867..2ad913732 100644
--- a/mods/src/patches/parts/alliance_store.cc
+++ b/mods/src/patches/parts/alliance_store.cc
@@ -1,30 +1,29 @@
-// Alliance Games store: native material research tooltips and currency refresh
-// after bundle readiness. One feature owner, no claim-trace or file probe.
+// alliance_store: native material research tooltips in the Alliance Games store, and its currency refresh once its
+// bundles are ready. One feature owner, no claim-trace or file probe. [patches] alliancegamesstorehooks.
+
 #include "patches/native_hook_extent.h"
-#include "patches/screen_update_hook.h"
+#include "patches/patches.h"
+
+#include "prime/Hub.h"
+#include "prime/inventory.h"
 
+#include <il2cpp/hook.h>
 #include <il2cpp/il2cpp.h>
 #include <il2cpp/method_contract.h>
-#include <prime/BundleDataWidget.h>
-#include <prime/Component.h>
-#include <prime/GameObject.h>
-#include <prime/Hub.h>
-#include <prime/LocaleTextContext.h>
-#include <prime/Transform.h>
-#include <prime/Vector2.h>
-
+#include <spdlog/spdlog.h>
 #include <spud/detour.h>
+#include <unity/core.h>
+
 #if _WIN32
 #include <Windows.h>
 #endif
-#include <spdlog/spdlog.h>
-#include <thread>
 
 #include <array>
 #include <chrono>
 #include <memory>
 #include <optional>
 #include <string>
+#include <thread>
 #include <utility>
 #include <vector>
 
@@ -32,305 +31,49 @@ namespace
 {
 using Clock = std::chrono::steady_clock;
 
-struct UnityObject {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Object">;
-};
-struct UnityResources {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Resources">;
-};
-
-// Digit.Client.Serialization.OverridableBool.
-struct OverridableBool {
-  bool serialized, current, modified;
-};
-static_assert(sizeof(OverridableBool) == 3);
-
-struct ActionLocaleSetting : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Actions", "ActionLocaleSetting">;
-};
-struct ActionLocaleSettingsList : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Actions", "ActionLocaleSettingsList">;
-};
-struct TooltipLoadAndShow : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Tooltip", "TooltipLoadAndShow">;
-};
-
-// A MonoBehaviour; the appearance fields are copied onto an action trigger that replaces it.
-struct TooltipTrigger : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Tooltip", "TooltipTrigger">;
-
-  OverridableBool showHeader()
-  { return Field<"_showHeader", OverridableBool>(); }
-  LocaleTextContext* header()
-  { return Field<"_header", LocaleTextContext*>(); }
-  OverridableBool showDescription()
-  { return Field<"_showDescription", OverridableBool>(); }
-  LocaleTextContext* description()
-  { return Field<"_description", LocaleTextContext*>(); }
-  bool overrideLocale()
-  { return Field<"_overrideLocale", bool>(); }
-  // Digit.Client.Tooltip.TooltipAnchor; -1 is Undefined.
-  int32_t anchorOverride()
-  { return Field<"_anchorOverride", int32_t>(); }
-  Vector2 sizeOverride()
-  { return Field<"_sizeOverride", Vector2>(); }
-  Transform* positionOverrideTarget()
-  { return Field<"_positionOverrideTarget", Transform*>(); }
-  Vector2 positionOverrideOffset()
-  { return Field<"_positionOverrideOffset", Vector2>(); }
-  bool isInteractable()
-  { return Field<"_isInteractable", bool>(); }
-  Il2CppString* descriptionOverrideText()
-  { return Field<"<DescriptionOverrideText>k__BackingField", Il2CppString*>(); }
-  TooltipLoadAndShow* loader()
-  { return Field<"_loader", TooltipLoadAndShow*>(); }
-
-  // Behaviour.enabled, distinguishing a failed call from the value.
-  std::optional<bool> Enabled()
-  { return TryCall<"get_enabled", bool()>(); }
-  bool SetEnabled(bool value)
-  { return TryCall<"set_enabled", void(bool)>(value); }
-};
-
-struct TooltipActionTrigger : TooltipTrigger {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Tooltip", "TooltipActionTrigger">;
-
-  void CopyAppearance(TooltipTrigger* plain)
-  {
-    SetField<"_showHeader">(plain->showHeader());
-    SetField<"_header">(plain->header());
-    SetField<"_showDescription">(plain->showDescription());
-    SetField<"_description">(plain->description());
-    SetField<"_overrideLocale">(plain->overrideLocale());
-    SetField<"_anchorOverride">(plain->anchorOverride());
-    SetField<"_sizeOverride">(plain->sizeOverride());
-    SetField<"_positionOverrideTarget">(plain->positionOverrideTarget());
-    SetField<"_positionOverrideOffset">(plain->positionOverrideOffset());
-    SetField<"_isInteractable">(plain->isInteractable());
-    SetField<"<DescriptionOverrideText>k__BackingField">(plain->descriptionOverrideText());
-    SetField<"_loader">(plain->loader());
-  }
-};
-
-// The tooltip on a shop card. Its context is the card's inventory item.
-struct InventoryTooltipTriggerWidget : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Inventories", "InventoryTooltipTriggerWidget">;
-
-  il2cpp::Object* Context()
-  { return Get<"Context", il2cpp::Object*>(); }
-  GameObject* gameObject()
-  { return Get<"gameObject", GameObject*>(); }
-
-  TooltipTrigger* tooltipTrigger()
-  { return Field<"_tooltipTrigger", TooltipTrigger*>(); }
-  void SetTooltipTrigger(TooltipTrigger* value)
-  { SetField<"_tooltipTrigger">(value); }
-  TooltipActionTrigger* tooltipActionTrigger()
-  { return Field<"_tooltipActionTrigger", TooltipActionTrigger*>(); }
-  void SetTooltipActionTrigger(TooltipActionTrigger* value)
-  { SetField<"_tooltipActionTrigger">(value); }
-  ActionLocaleSetting* searchActionLocaleSetting()
-  { return Field<"_searchActionLocaleSetting", ActionLocaleSetting*>(); }
-  void SetSearchActionLocaleSetting(ActionLocaleSetting* value)
-  { SetField<"_searchActionLocaleSetting">(value); }
-  ActionLocaleSetting* actionLocaleSetting()
-  { return Field<"_actionLocaleSetting", ActionLocaleSetting*>(); }
-  void SetActionLocaleSetting(ActionLocaleSetting* value)
-  { SetField<"_actionLocaleSetting">(value); }
-  ActionLocaleSettingsList* settings()
-  { return Field<"_settings", ActionLocaleSettingsList*>(); }
-  void SetSettings(ActionLocaleSettingsList* value)
-  { SetField<"_settings">(value); }
-
-  bool UpdateTooltipDescription()
-  { return TryCall<"UpdateTooltipDescription", void()>(); }
-  bool SetupActionTooltipTrigger()
-  { return TryCall<"SetupActionTooltipTrigger", void()>(); }
-};
-
-// Digit.Client.UI.SmartScrollerBase, the store's card pool.
-struct SmartScrollerBase : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "SmartScrollerBase">;
-
-  il2cpp::List<il2cpp::Object*>* spawnedItems()
-  { return Field<"_spawnedItems", il2cpp::List<il2cpp::Object*>*>(); }
-  bool regeneratingContent()
-  { return Field<"_regeneratingContent", bool>(); }
-  il2cpp::Object* spawnerCoroutine()
-  { return Field<"_spawnerCoroutine", il2cpp::Object*>(); }
-  il2cpp::Object* dataHeldWhilstInitializing()
-  { return Field<"_dataHeldWhilstInitializing", il2cpp::Object*>(); }
-
-  std::optional<Vector2> NormalizedPosition()
-  { return TryCall<"get_NormalizedPosition", Vector2()>(); }
-  bool OnValueChangedCallback(Vector2 value)
-  { return TryCall<"OnValueChangedCallback", void(Vector2)>(value); }
-  std::optional<int32_t> VisibleItemsCount()
-  { return TryCall<"get_VisibleItemsCount", int32_t()>(); }
-  std::optional<float> ScrollPosition()
-  { return TryCall<"get_ScrollPosition", float()>(); }
-};
-
-struct ShopListScrollerViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Shop", "ShopListScrollerViewController">;
-
-  // Declared as some scroller; only a SmartScrollerBase is used.
-  il2cpp::Object* smartScroller()
-  { return Field<"_smartScroller", il2cpp::Object*>(); }
-};
-
-// The store's context; its members resolve on the runtime class.
-struct AllianceGamesStoreContext : il2cpp::Object {
-  bool IsShopViewActive()
-  { return Get<"IsShopViewActive", bool>(); }
-  std::optional<bool> IsFetchingBundlesInProgress()
-  { return TryCall<"get_IsFetchingBundlesInProgress", bool()>(); }
-  int32_t BundlesCount()
-  { return Get<"BundlesCount", int32_t>(); }
-  il2cpp::Object* StoreCurrency()
-  { return Get<"StoreCurrency", il2cpp::Object*>(); }
-  bool UpdateStoreCurrency()
-  { return TryCall<"UpdateStoreCurrency", void()>(); }
-};
-
-struct AllianceGamesStoreScrollerViewController : ShopListScrollerViewController {
-  using Class =
-      il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Alliances.Games", "AllianceGamesStoreScrollerViewController">;
-
-  AllianceGamesStoreContext* AllianceGamesContext()
-  { return Get<"AllianceGamesContext", AllianceGamesStoreContext*>(); }
-};
-
-InventoryTooltipTriggerWidget* BundleTooltip(BundleDataWidget* card)
-{ return card->Field<"_invTooltip", InventoryTooltipTriggerWidget*>(); }
-ShopListScrollerViewController* BundleOwner(BundleDataWidget* card)
-{ return card->Field<"_scrollerController", ShopListScrollerViewController*>(); }
-
-// Upstream refuses to install when the native field contract changed: the hooks write these fields, and a missing
-// one would read as zero.
-template <typename Binding, il2cpp::Name N, typename T> bool StoreHasField()
-{ return il2cpp::detail::ResolveField(Binding::Class::Raw(), N.View(), il2cpp::detail::SlotOf<T>(), false); }
+bool            alliance_store_active = false;
+std::thread::id alliance_store_thread;
+bool            StoreThread()
+{ return alliance_store_active && std::this_thread::get_id() == alliance_store_thread; }
 
-bool StoreFieldsResolve()
-{
-  using Widget   = InventoryTooltipTriggerWidget;
-  using Trigger  = TooltipTrigger;
-  using Scroller = SmartScrollerBase;
-  bool ok        = true;
-  ok &= StoreHasField<Widget, "_tooltipTrigger", TooltipTrigger*>();
-  ok &= StoreHasField<Widget, "_tooltipActionTrigger", TooltipActionTrigger*>();
-  ok &= StoreHasField<Widget, "_searchActionLocaleSetting", ActionLocaleSetting*>();
-  ok &= StoreHasField<Widget, "_actionLocaleSetting", ActionLocaleSetting*>();
-  ok &= StoreHasField<Widget, "_settings", ActionLocaleSettingsList*>();
-  ok &= StoreHasField<Trigger, "_showHeader", OverridableBool>();
-  ok &= StoreHasField<Trigger, "_showDescription", OverridableBool>();
-  ok &= StoreHasField<Trigger, "_header", LocaleTextContext*>();
-  ok &= StoreHasField<Trigger, "_description", LocaleTextContext*>();
-  ok &= StoreHasField<Trigger, "_overrideLocale", bool>();
-  ok &= StoreHasField<Trigger, "_anchorOverride", int32_t>();
-  ok &= StoreHasField<Trigger, "_sizeOverride", Vector2>();
-  ok &= StoreHasField<Trigger, "_positionOverrideOffset", Vector2>();
-  ok &= StoreHasField<Trigger, "_positionOverrideTarget", Transform*>();
-  ok &= StoreHasField<Trigger, "_isInteractable", bool>();
-  ok &= StoreHasField<Trigger, "<DescriptionOverrideText>k__BackingField", Il2CppString*>();
-  ok &= StoreHasField<Trigger, "_loader", TooltipLoadAndShow*>();
-  ok &= StoreHasField<ShopListScrollerViewController, "_smartScroller", il2cpp::Object*>();
-  ok &= StoreHasField<Scroller, "_spawnedItems", il2cpp::List<il2cpp::Object*>*>();
-  ok &= StoreHasField<BundleDataWidget, "_invTooltip", InventoryTooltipTriggerWidget*>();
-  ok &= StoreHasField<BundleDataWidget, "_scrollerController", ShopListScrollerViewController*>();
-  ok &= StoreHasField<Scroller, "_regeneratingContent", bool>();
-  ok &= StoreHasField<Scroller, "_spawnerCoroutine", il2cpp::Object*>();
-  ok &= StoreHasField<Scroller, "_dataHeldWhilstInitializing", il2cpp::Object*>();
-  return ok;
-}
+struct AllianceStoreWork {
+  il2cpp::GcHandle  source;
+  uint64_t          epoch   = 0;
+  bool              pending = false, currency = false, refreshing_currency = false, layout = false;
+  Clock::time_point due{};
+} alliance_store_work;
 
-// Unity's bool(Object): false for null and for destroyed native objects.
-bool Alive(il2cpp::Object* object)
-{ return object && UnityObject::Class::Call<"op_Implicit", bool>(object); }
+enum class ResearchUpdate { Unchanged, Upgraded, Restored, Unavailable, Failed };
 
 bool IsStore(il2cpp::Object* object)
 { return object && object->Is<AllianceGamesStoreScrollerViewController>(); }
 
+bool SameStoreItem(InventoryTooltipTriggerWidget* tooltip, TooltipItem* item)
+{ return unity::Alive(tooltip) && tooltip->Context() == item; }
+
 // Native research eligibility of the card's resource. Empty when it cannot be determined.
-std::optional<bool> Eligible(il2cpp::Object* item, il2cpp::GcRoots& roots)
+std::optional<bool> Eligible(TooltipItem* item)
 {
-  auto* spec = roots.Keep(item->Get<"ResourceSpec", il2cpp::Object*>());
-  auto  id   = spec ? spec->Get<"Id", int64_t>() : 0;
+  const auto id = item->ResourceId();
   if (id <= 0)
     return std::nullopt;
-  auto* manager = roots.Keep(Hub::Class::Get<"ResearchManager", il2cpp::Object*>());
-  // Digit.PrimeServer.Models.ResearchTreeType; 0 is the main tree.
-  enum class ResearchTreeType : int32_t {};
-  return manager ? manager->TryCall<"IsResourceRequiredByVisibleResearches", bool(int64_t, ResearchTreeType)>(
-                       id, ResearchTreeType{})
-                 : std::nullopt;
-}
-
-std::optional<int32_t> CurrencyCount(AllianceGamesStoreContext* context, il2cpp::GcRoots& roots)
-{
-  auto* currencies = roots.Keep(context->StoreCurrency());
-  auto* soft = currencies ? roots.Keep(currencies->Get<"SoftResources", il2cpp::List<il2cpp::Object*>*>()) : nullptr;
-  return soft ? soft->TryCall<"get_Count", int32_t()>() : std::nullopt;
-}
-
-// The action trigger on the widget's GameObject; with `create`, added when there is none. Null when the lookup
-// failed, so a failed lookup never adds a second component.
-TooltipActionTrigger* ActionComponent(InventoryTooltipTriggerWidget* widget, bool create, il2cpp::GcRoots& roots)
-{
-  auto* object = roots.Keep(widget->gameObject());
-  auto* type   = object ? roots.Keep(TooltipActionTrigger::Class::TypeObject()) : nullptr;
-  if (!type)
-    return nullptr;
-  const auto found = object->TryCall<"GetComponent", TooltipActionTrigger*(Il2CppReflectionType*)>(type);
-  if (!found)
-    return nullptr;
-  if (*found)
-    return roots.Keep(*found);
-  return create ? roots.Keep(object->AddComponent<TooltipActionTrigger>()) : nullptr;
-}
-
-// The widget's own plain trigger, not an action trigger.
-TooltipTrigger* PlainComponent(InventoryTooltipTriggerWidget* widget, il2cpp::GcRoots& roots)
-{
-  auto* object = roots.Keep(widget->gameObject());
-  auto* value  = object ? roots.Keep(object->GetComponent<TooltipTrigger>()) : nullptr;
-  return value && value->klass == TooltipTrigger::Class::Raw() ? value : nullptr;
+  auto* manager = Hub::Research();
+  return manager ? manager->IsResourceRequiredByVisibleResearches(id) : std::nullopt;
 }
 
 // A loaded tooltip widget that carries native research actions, whose locale settings the store cards borrow.
 InventoryTooltipTriggerWidget* Template(il2cpp::GcRoots& roots)
 {
-  auto* type  = roots.Keep(InventoryTooltipTriggerWidget::Class::TypeObject());
-  auto* found = type ? roots.Keep(UnityResources::Class::Call<"FindObjectsOfTypeAll", il2cpp::Array<il2cpp::Object*>*>(
-                           type))
-                     : nullptr;
+  auto* found = roots.Keep(unity::FindObjectsOfTypeAll<InventoryTooltipTriggerWidget>());
   if (!found)
     return nullptr;
-  for (auto* object : *found) {
-    auto* widget = object ? object->As<InventoryTooltipTriggerWidget>() : nullptr;
-    if (widget && widget->tooltipActionTrigger() && widget->searchActionLocaleSetting())
+  for (auto* widget : *found)
+    if (widget && widget->Is<InventoryTooltipTriggerWidget>() && widget->tooltipActionTrigger()
+        && widget->searchActionLocaleSetting())
       return roots.Keep(widget);
-  }
   return nullptr;
 }
 
-bool            alliance_store_active = false;
-std::thread::id alliance_store_thread;
-bool            StoreThread()
-{ return alliance_store_active && std::this_thread::get_id() == alliance_store_thread; }
-
-struct AllianceStoreWork {
-  il2cpp::GcHandle  source;
-  uint64_t          epoch   = 0;
-  bool              pending = false, currency = false, refreshing_currency = false, layout = false;
-  Clock::time_point due{};
-} alliance_store_work;
-
-enum class ResearchUpdate { Unchanged, Upgraded, Restored, Unavailable, Failed };
-
-bool SameStoreItem(InventoryTooltipTriggerWidget* tooltip, il2cpp::Object* item)
-{ return Alive(tooltip) && tooltip->Context() == item; }
-
 // Weak component identity survives pooled reuse without retaining a scene. Only
 // the original serialized assets stay rooted while our replacement is bound.
 struct OwnedStoreTooltip {
@@ -376,7 +119,7 @@ bool RestoreStoreTooltip(OwnedStoreTooltip& entry)
   auto*           action = roots.Keep(entry.action.Get<TooltipActionTrigger>());
   if (!roots.healthy() || !widget || !plain || !action)
     return false;
-  if (!Alive(widget)) {
+  if (!unity::Alive(widget)) {
     ReleaseStoreAssets(entry);
     return true;
   }
@@ -385,18 +128,18 @@ bool RestoreStoreTooltip(OwnedStoreTooltip& entry)
       || (widget->tooltipActionTrigger() && widget->tooltipActionTrigger() != action)) {
     // A new native owner replaced our arrangement. Disable only our component;
     // never overwrite the replacement owner's fields or enabled state.
-    (void)action->SetEnabled(false);
+    (void)action->TrySetEnabled(false);
     ReleaseStoreAssets(entry);
     return true;
   }
-  bool ok = action->SetEnabled(false);
+  bool ok = action->TrySetEnabled(false);
   widget->SetTooltipTrigger(plain);
   widget->SetTooltipActionTrigger(nullptr);
   widget->SetSearchActionLocaleSetting(entry.search.Get<ActionLocaleSetting>());
   widget->SetActionLocaleSetting(entry.locale.Get<ActionLocaleSetting>());
   widget->SetSettings(entry.settings.Get<ActionLocaleSettingsList>());
   ok &= widget->UpdateTooltipDescription();
-  ok &= plain->SetEnabled(entry.plain_enabled);
+  ok &= plain->TrySetEnabled(entry.plain_enabled);
   if (ok)
     ReleaseStoreAssets(entry);
   return ok;
@@ -410,14 +153,14 @@ ResearchUpdate ReconcileStoreTooltip(InventoryTooltipTriggerWidget* tooltip, Inv
     return ResearchUpdate::Unavailable;
   const auto epoch     = alliance_store_work.epoch;
   auto*      store     = roots.Keep(alliance_store_work.source.Get<AllianceGamesStoreScrollerViewController>());
-  auto*      item      = Alive(tooltip) ? roots.Keep(tooltip->Context()) : nullptr;
+  auto*      item      = unity::Alive(tooltip) ? roots.Keep(tooltip->Context()) : nullptr;
   auto       same_item = [&] {
     if (!store || alliance_store_work.epoch != epoch || alliance_store_work.source.Get() != store)
       return false;
-    return Alive(store) && SameStoreItem(tooltip, item) && alliance_store_work.epoch == epoch
+    return unity::Alive(store) && SameStoreItem(tooltip, item) && alliance_store_work.epoch == epoch
            && alliance_store_work.source.Get() == store;
   };
-  auto* plain = item ? PlainComponent(tooltip, roots) : nullptr;
+  auto* plain = item ? roots.Keep(tooltip->PlainTrigger()) : nullptr;
   if (!plain)
     return ResearchUpdate::Unchanged;
   auto* old_action  = roots.Keep(tooltip->tooltipActionTrigger());
@@ -427,7 +170,7 @@ ResearchUpdate ReconcileStoreTooltip(InventoryTooltipTriggerWidget* tooltip, Inv
   if (!roots.healthy() || (old_action && (!owned || owned->action.Get() != old_action))
       || (old_action ? old_trigger != old_action : old_trigger != plain))
     return ResearchUpdate::Unchanged;
-  const auto eligible = Eligible(item, roots);
+  const auto eligible = Eligible(item);
   if (!eligible || !same_item())
     return ResearchUpdate::Unavailable;
   if (!*eligible)
@@ -441,15 +184,19 @@ ResearchUpdate ReconcileStoreTooltip(InventoryTooltipTriggerWidget* tooltip, Inv
   auto*      locale        = roots.Keep(donor->actionLocaleSetting());
   auto*      settings      = roots.Keep(donor->settings());
   auto*      loader        = roots.Keep(plain->loader());
-  const auto plain_enabled = plain->Enabled();
+  const auto plain_enabled = plain->TryEnabled();
   if (!roots.healthy() || !search || !loader || !plain_enabled || !same_item())
     return ResearchUpdate::Unavailable;
-  auto* action = ActionComponent(tooltip, false, roots);
+  // A failed lookup must not add a second component.
+  const auto existing = tooltip->ActionTrigger();
+  if (!existing)
+    return ResearchUpdate::Unavailable;
+  auto* action = roots.Keep(*existing);
   // Reuse only the disabled component this feature previously added.
   if (action && (!owned || owned->action.Get() != action))
     return ResearchUpdate::Unchanged;
   if (!action)
-    action = ActionComponent(tooltip, true, roots);
+    action = roots.Keep(tooltip->AddActionTrigger());
   if (!action)
     return ResearchUpdate::Unavailable;
   if (!owned) {
@@ -458,7 +205,7 @@ ResearchUpdate ReconcileStoreTooltip(InventoryTooltipTriggerWidget* tooltip, Inv
     entry->plain  = il2cpp::GcHandle::Weak(plain);
     entry->action = il2cpp::GcHandle::Weak(action);
     if (entry->widget.Get() != tooltip || entry->plain.Get() != plain || entry->action.Get() != action) {
-      (void)action->SetEnabled(false);
+      (void)action->TrySetEnabled(false);
       return ResearchUpdate::Unavailable;
     }
     alliance_store_tooltips.push_back(std::move(entry));
@@ -473,13 +220,13 @@ ResearchUpdate ReconcileStoreTooltip(InventoryTooltipTriggerWidget* tooltip, Inv
     if (!retain(tooltip->searchActionLocaleSetting(), owned->search)
         || !retain(tooltip->actionLocaleSetting(), owned->locale) || !retain(tooltip->settings(), owned->settings)) {
       ReleaseStoreAssets(*owned);
-      (void)action->SetEnabled(false);
+      (void)action->TrySetEnabled(false);
       return ResearchUpdate::Unavailable;
     }
     owned->store = il2cpp::GcHandle::Weak(store);
     if (owned->store.Get() != store) {
       ReleaseStoreAssets(*owned);
-      (void)action->SetEnabled(false);
+      (void)action->TrySetEnabled(false);
       return ResearchUpdate::Unavailable;
     }
     owned->plain_enabled = *plain_enabled;
@@ -497,7 +244,7 @@ ResearchUpdate ReconcileStoreTooltip(InventoryTooltipTriggerWidget* tooltip, Inv
     }
   } rollback{owned};
 
-  if (!action->SetEnabled(false))
+  if (!action->TrySetEnabled(false))
     return ResearchUpdate::Failed;
   action->CopyAppearance(plain);
   if (!current())
@@ -508,9 +255,9 @@ ResearchUpdate ReconcileStoreTooltip(InventoryTooltipTriggerWidget* tooltip, Inv
   tooltip->SetTooltipTrigger(action);
   tooltip->SetTooltipActionTrigger(action);
   if (!tooltip->UpdateTooltipDescription() || !current() || !tooltip->SetupActionTooltipTrigger() || !current()
-      || !plain->SetEnabled(false) || !action->SetEnabled(true) || !current())
+      || !plain->TrySetEnabled(false) || !action->TrySetEnabled(true) || !current())
     return ResearchUpdate::Failed;
-  const auto enabled = action->Enabled();
+  const auto enabled = action->TryEnabled();
   if (!current() || !enabled || !*enabled || tooltip->tooltipTrigger() != action
       || tooltip->tooltipActionTrigger() != action)
     return ResearchUpdate::Failed;
@@ -586,7 +333,7 @@ void BundleDataWidget_OnAboutToReleaseContext_Hook(auto original, BundleDataWidg
     original(self);
     return;
   }
-  if (auto entry = OwnedTooltip(BundleTooltip(self)))
+  if (auto entry = OwnedTooltip(self->invTooltip()))
     (void)RestoreStoreTooltip(*entry);
   original(self);
 }
@@ -595,7 +342,7 @@ void QueueStoreCard(BundleDataWidget* self)
 {
   // Native OnDidBindContext sets this AFTER SetupTooltip. Never use the
   // RefreshBundle argument or a pre-bind owner as current-card identity.
-  auto* owner = BundleOwner(self);
+  auto* owner = self->scrollerController();
   if (owner && alliance_store_work.source.Get() == owner && IsStore(owner))
     QueueStore(static_cast<AllianceGamesStoreScrollerViewController*>(owner), false);
 }
@@ -621,20 +368,20 @@ void BundleDataWidget_OnDidBindContext_Hook(auto original, BundleDataWidget* sel
 std::string StoreCount(const auto& value)
 { return value ? std::to_string(*value) : "unavailable"; }
 
-void AllianceStoreFrame()
+void AllianceGamesStoreFrame()
 {
   if (!StoreThread())
     return;
   auto& work = alliance_store_work;
   if (!work.pending || Clock::now() < work.due)
     return;
-  const bool currency = std::exchange(work.currency, false);
-  const bool layout   = std::exchange(work.layout, false);
-  work.pending        = false;
+  const bool currency   = std::exchange(work.currency, false);
+  const bool layout     = std::exchange(work.layout, false);
+  work.pending          = false;
   const auto      epoch = work.epoch;
   il2cpp::GcRoots roots;
   auto*           source  = roots.Keep(work.source.Get<AllianceGamesStoreScrollerViewController>());
-  auto*           context = source && Alive(source) ? roots.Keep(source->AllianceGamesContext()) : nullptr;
+  auto*           context = source && unity::Alive(source) ? roots.Keep(source->AllianceGamesContext()) : nullptr;
   if (!context || !context->IsShopViewActive())
     return;
   if (work.epoch != epoch || work.source.Get() != source)
@@ -651,7 +398,7 @@ void AllianceStoreFrame()
   bool position_notified = false;
   if (layout && smart) {
     const auto position = smart->NormalizedPosition();
-    if (position && Alive(smart) && work.epoch == epoch && work.source.Get() == source
+    if (position && unity::Alive(smart) && work.epoch == epoch && work.source.Get() == source
         && source->smartScroller() == smart) {
       position_notified = smart->OnValueChangedCallback(*position);
     }
@@ -663,20 +410,15 @@ void AllianceStoreFrame()
   if (!count || *count < 0)
     return;
   int                            upgraded = 0, restored = 0, unavailable = 0, failed = 0;
-  InventoryTooltipTriggerWidget* donor        = nullptr;
-  auto*                          tooltip_type = roots.Keep(InventoryTooltipTriggerWidget::Class::TypeObject());
-  if (!tooltip_type)
-    return;
+  InventoryTooltipTriggerWidget* donor = nullptr;
   for (int32_t index = 0; index < *count; ++index) {
     if (work.epoch != epoch || work.source.Get() != source)
       return;
     il2cpp::GcRoots card_roots;
-    auto*           rect = card_roots.Keep((*pool)[index]);
-    if (!rect || !Alive(rect))
+    auto*           card = card_roots.Keep((*pool)[index]);
+    if (!card || !unity::Alive(card))
       continue;
-    auto* tooltip =
-        card_roots.Keep(rect->Call<"GetComponentInChildren", InventoryTooltipTriggerWidget*(Il2CppReflectionType*, bool)>(
-            tooltip_type, true));
+    auto* tooltip = card_roots.Keep(SmartScrollerBase::CardTooltip(card));
     switch (tooltip ? ReconcileStoreTooltip(tooltip, donor, roots) : ResearchUpdate::Unchanged) {
       case ResearchUpdate::Upgraded:
         ++upgraded;
@@ -707,11 +449,11 @@ void AllianceStoreFrame()
       ~Reset()
       { value = false; }
     } reset{work.refreshing_currency};
-    currency_before = CurrencyCount(context, roots);
-    if (source->AllianceGamesContext() == context && Alive(source) && work.epoch == epoch
+    currency_before = context->CurrencyCount();
+    if (source->AllianceGamesContext() == context && unity::Alive(source) && work.epoch == epoch
         && work.source.Get() == source) {
       refreshed      = context->UpdateStoreCurrency();
-      currency_after = CurrencyCount(context, roots);
+      currency_after = context->CurrencyCount();
     }
   }
   if (layout)
@@ -745,24 +487,20 @@ bool StoreHookFits(const MethodInfo* method)
   return false;
 #endif
 }
-} // namespace
 
-void InstallAllianceGamesStoreHooks()
+void InstallAllianceGamesStore()
 {
-  static bool attempted = false;
-  if (std::exchange(attempted, true))
-    return;
+  using il2cpp::contract::Resolve;
   auto*            store = AllianceGamesStoreScrollerViewController::Class::Raw();
   auto*            shop  = ShopListScrollerViewController::Class::Raw();
   auto*            card  = BundleDataWidget::Class::Raw();
-  const std::array targets{
-      method_contract::Resolve(store, "OnDidBindCanvasContext", false, "System.Void", {}),
-      method_contract::Resolve(store, "OnAboutToReleaseCanvasContext", false, "System.Void", {}),
-      method_contract::Resolve(shop, "RegenerateSortedBundles", false, "System.Void", {"System.Boolean"}),
-      method_contract::Resolve(card, "RefreshBundle", false, "System.Void", {"Digit.PrimePlatform.Content.Bundle"}),
-      method_contract::Resolve(card, "OnAboutToReleaseContext", false, "System.Void", {}),
-      method_contract::Resolve(card, "OnDidBindContext", false, "System.Void", {})};
-  if (!StoreFieldsResolve()) {
+  const std::array targets{Resolve(store, "OnDidBindCanvasContext", false, "System.Void", {}),
+                           Resolve(store, "OnAboutToReleaseCanvasContext", false, "System.Void", {}),
+                           Resolve(shop, "RegenerateSortedBundles", false, "System.Void", {"System.Boolean"}),
+                           Resolve(card, "RefreshBundle", false, "System.Void", {"Digit.PrimePlatform.Content.Bundle"}),
+                           Resolve(card, "OnAboutToReleaseContext", false, "System.Void", {}),
+                           Resolve(card, "OnDidBindContext", false, "System.Void", {})};
+  if (!AllianceGamesStoreFieldsPresent()) {
     spdlog::warn("[AllianceGamesStore] unavailable: native field contract changed");
     return;
   }
@@ -777,23 +515,26 @@ void InstallAllianceGamesStoreHooks()
         return;
       }
   }
-  if (!install_screen_manager_update_hook() || !register_screen_manager_update_callback(AllianceStoreFrame)) {
-    spdlog::warn("[AllianceGamesStore] unavailable: shared frame delivery");
-    return;
-  }
-  // Old SPUD has no hook transaction/rollback API. Preflight every target first,
-  // attempt once, and leave all installed callbacks native-only unless complete.
+  // Every target is checked first; the detours are attempted once, and the hooks stay native-only unless all went
+  // in. The frame work runs from the frame tick; without the tick the hooks only record pending work.
   const bool complete =
-      SPUD_STATIC_DETOUR(method_contract::Pointer(targets[0]), AllianceStoreScroller_OnDidBindCanvasContext_Hook)
-      && SPUD_STATIC_DETOUR(method_contract::Pointer(targets[1]),
-                            AllianceStoreScroller_OnAboutToReleaseCanvasContext_Hook)
-      && SPUD_STATIC_DETOUR(method_contract::Pointer(targets[2]),
-                            ShopListScrollerViewController_RegenerateSortedBundles_Hook)
-      && SPUD_STATIC_DETOUR(method_contract::Pointer(targets[3]), BundleDataWidget_RefreshBundle_Hook)
-      && SPUD_STATIC_DETOUR(method_contract::Pointer(targets[4]), BundleDataWidget_OnAboutToReleaseContext_Hook)
-      && SPUD_STATIC_DETOUR(method_contract::Pointer(targets[5]), BundleDataWidget_OnDidBindContext_Hook);
+      IL2CPP_DETOUR(targets[0]->methodPointer, AllianceStoreScroller_OnDidBindCanvasContext_Hook,
+                    "AllianceGamesStoreScrollerViewController.OnDidBindCanvasContext")
+      && IL2CPP_DETOUR(targets[1]->methodPointer, AllianceStoreScroller_OnAboutToReleaseCanvasContext_Hook,
+                       "AllianceGamesStoreScrollerViewController.OnAboutToReleaseCanvasContext")
+      && IL2CPP_DETOUR(targets[2]->methodPointer, ShopListScrollerViewController_RegenerateSortedBundles_Hook,
+                       "ShopListScrollerViewController.RegenerateSortedBundles")
+      && IL2CPP_DETOUR(targets[3]->methodPointer, BundleDataWidget_RefreshBundle_Hook, "BundleDataWidget.RefreshBundle")
+      && IL2CPP_DETOUR(targets[4]->methodPointer, BundleDataWidget_OnAboutToReleaseContext_Hook,
+                       "BundleDataWidget.OnAboutToReleaseContext")
+      && IL2CPP_DETOUR(targets[5]->methodPointer, BundleDataWidget_OnDidBindContext_Hook,
+                       "BundleDataWidget.OnDidBindContext");
   alliance_store_thread = std::this_thread::get_id();
   alliance_store_active = complete;
   if (!complete)
     spdlog::warn("[AllianceGamesStore] unavailable: incomplete detour installation; adapters inactive");
 }
+} // namespace
+
+const Feature kAllianceGamesStore{"AllianceGamesStore", &Config::Patches::alliancegamesstorehooks,
+                                  InstallAllianceGamesStore, AllianceGamesStoreFrame};
diff --git a/mods/src/patches/parts/artifact_exchange.cc b/mods/src/patches/parts/artifact_exchange.cc
deleted file mode 100644
index 7335a728e..000000000
--- a/mods/src/patches/parts/artifact_exchange.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-// disable_exchange_all: hides the artifact shards popup's Exchange All button. Individual exchanges stay available.
-
-#include "config.h"
-
-#include "prime/Component.h"
-
-#include <il2cpp/il2cpp.h>
-#include <spdlog/spdlog.h>
-#include <spud/detour.h>
-
-namespace
-{
-struct InventoryUsePopupViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Inventories", "InventoryUsePopupViewController">;
-
-  // Only artifact bulk conversion uses this button, not the inventory entry button or single exchanges.
-  Component* convertAllButton()
-  { return Field<"_convertAllButton", Component*>(); }
-};
-
-void InventoryUsePopupViewController_OnDidBindCanvasContext_Hook(auto original, InventoryUsePopupViewController* _this)
-{
-  original(_this);
-  if (!_this || !Config::Get().disable_exchange_all)
-    return;
-  auto* button = _this->convertAllButton();
-  if (auto* object = button ? button->gameObject() : nullptr)
-    object->SetActive(false);
-}
-} // namespace
-
-void InstallArtifactExchangeHooks()
-{
-  if (auto m = InventoryUsePopupViewController::Class::Method("OnDidBindCanvasContext", 0))
-    SPUD_STATIC_DETOUR(m.Pointer(), InventoryUsePopupViewController_OnDidBindCanvasContext_Hook);
-}
diff --git a/mods/src/patches/parts/audio_events.cc b/mods/src/patches/parts/audio_events.cc
index 4b109e975..7cd523687 100644
--- a/mods/src/patches/parts/audio_events.cc
+++ b/mods/src/patches/parts/audio_events.cc
@@ -1,50 +1,41 @@
+// [audio]: logs the game's sound events by name, and mutes the ones in disabled_events.
+
 #include "config.h"
+#include "patches/patches.h"
 #include "str_utils.h"
 
-#include <il2cpp/il2cpp.h>
+#include "prime/Hub.h"
 
-#include <spud/detour.h>
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
 #include <spdlog/spdlog.h>
 
 #include <algorithm>
 #include <string>
 
-struct FabricEventManager {
-};
-
-// Fabric.EventManager.PostEvent(string, EventAction, object, GameObject,
-// InitialiseParameters, bool, OnEventNotify)
-bool FabricEventManager_PostEvent_Hook(auto original, FabricEventManager* _this, Il2CppString* event_name,
-                                       int event_action, Il2CppObject* parameter, Il2CppObject* parent_game_object,
-                                       Il2CppObject* initialise_parameters, bool add_to_queue,
-                                       Il2CppObject* on_event_notify)
+namespace
 {
-  if (event_name == nullptr) {
-    return original(_this, event_name, event_action, parameter, parent_game_object, initialise_parameters,
-                    add_to_queue, on_event_notify);
-  }
-
-  const auto event = to_string(event_name);
-  auto&      config = Config::Get();
-
-  if (config.trace_audio_events) {
-    spdlog::info("Audio event: {}", event);
-  }
-
-  if ((config.disable_all_audio_events ? event_action == 0 || event_action == 3 || event_action == 16 || event_action == 33 : std::ranges::find(config.disabled_audio_events, event) != config.disabled_audio_events.end())) {
-    spdlog::debug("Suppressed audio event: {}", event);
-    return false;
+// Fabric.EventManager.PostEvent(string, EventAction, object, GameObject, InitialiseParameters, bool, OnEventNotify)
+bool AudioEventManager_PostEvent_Hook(auto original, Il2CppObject* _this, Il2CppString* event_name, int event_action,
+                                      Il2CppObject* parameter, Il2CppObject* parent_game_object,
+                                      Il2CppObject* initialise_parameters, bool add_to_queue,
+                                      Il2CppObject* on_event_notify)
+{
+  if (const auto& audio = Config::Get().audio; event_name && (audio.trace_events || audio.disable_all_events || !audio.disabled_events.empty())) {
+    const auto event = il2cpp::ToUtf8(event_name);
+    if (audio.trace_events)
+      spdlog::info("Audio event: {}", event);
+    if ((audio.disable_all_events ? event_action == 0 || event_action == 3 || event_action == 16 || event_action == 33 : std::ranges::find(audio.disabled_events, event) != audio.disabled_events.end())) {
+      spdlog::debug("Suppressed audio event: {}", event);
+      return false;
+    }
   }
-
-  return original(_this, event_name, event_action, parameter, parent_game_object, initialise_parameters,
-                  add_to_queue, on_event_notify);
+  return original(_this, event_name, event_action, parameter, parent_game_object, initialise_parameters, add_to_queue,
+                  on_event_notify);
 }
 
-void InstallAudioEventHooks()
-{
-  using EventManager = il2cpp::Class<"Fabric.Core", "Fabric", "EventManager">;
+void InstallAudio()
+{ IL2CPP_HOOK(AudioEventManager::Method("PostEvent", 7), AudioEventManager_PostEvent_Hook); }
+} // namespace
 
-  // The shorter PostEvent overloads funnel into this seven-argument overload.
-  if (auto method = EventManager::Method("PostEvent", 7))
-    SPUD_STATIC_DETOUR(method.Pointer(), FabricEventManager_PostEvent_Hook);
-}
+const Feature kAudio{"Audio", &Config::Patches::audioeventhooks, InstallAudio};
diff --git a/mods/src/patches/parts/buff_fixes.cc b/mods/src/patches/parts/buff_fixes.cc
index 89e1bedbf..78c8f51be 100644
--- a/mods/src/patches/parts/buff_fixes.cc
+++ b/mods/src/patches/parts/buff_fixes.cc
@@ -1,33 +1,44 @@
+// Buffs: use_out_of_dock_power, so the ship power shown in the dock matches the power out in space, and a guard
+// against a buff list the game cannot handle.
+
 #include "config.h"
-#include "prime_types.h"
+#include "patches/patches.h"
 
-#include <il2cpp/il2cpp.h>
-#include <prime/IBuffComparer.h>
-#include <prime/IBuffData.h>
+#include "prime/server.h"
 
-#include <spud/detour.h>
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
 
-static bool BuffService_IsBuffConditionMet(auto original, void* _this, BuffCondition currentCondition,
-                                           IBuffComparer *buffComparer, IBuffData *buffToCompare,
-                                           bool excludeFactionBuffs, bool isAllianceLoyalty)
+namespace
 {
-  switch (currentCondition) {
-    case BuffCondition::CondSelfAtStation:
-      return false;
-
-    default:
-      break;
-  }
-
+// Leaves out the buffs that only apply while docked at the station.
+bool BuffService_IsBuffConditionMet_Hook(auto original, void* _this, BuffCondition currentCondition,
+                                         IBuffComparer* buffComparer, IBuffData* buffToCompare,
+                                         bool excludeFactionBuffs, bool isAllianceLoyalty)
+{
+  if (currentCondition == BuffCondition::CondSelfAtStation && Config::Get().buffs.use_out_of_dock_power)
+    return false;
   return original(_this, currentCondition, buffComparer, buffToCompare, excludeFactionBuffs, isAllianceLoyalty);
 }
 
-void InstallBuffFixHooks()
+// List<IBuffData> in and out, read untyped so a drifted IBuffData binding cannot make every buff look null. A list
+// with a null buff crashes the game, so it is answered with no buffs instead.
+il2cpp::List<il2cpp::Object*>* BuffService_ExtractBuffsOfType_Hook(auto original, ClientModifierType modifier,
+                                                                   il2cpp::List<il2cpp::Object*>* list)
 {
-  using BuffService = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "BuffService">;
-
-  if (Config::Get().use_out_of_dock_power) {
-    if (auto method = BuffService::Method("IsBuffConditionMet"))
-      SPUD_STATIC_DETOUR(method.Pointer(), BuffService_IsBuffConditionMet);
-  }
+  if (list)
+    for (auto* buff : *list)
+      if (!buff)
+        return nullptr;
+  return original(modifier, list);
 }
+
+void InstallOutOfDockPower()
+{ IL2CPP_HOOK(BuffService::Method("IsBuffConditionMet"), BuffService_IsBuffConditionMet_Hook); }
+
+void InstallBuffCrashGuard()
+{ IL2CPP_HOOK(BuffService::Method("ExtractBuffsOfType"), BuffService_ExtractBuffsOfType_Hook); }
+} // namespace
+
+const Feature kOutOfDockPower{"OutOfDockPower", &Config::Patches::bufffixhooks, InstallOutOfDockPower};
+const Feature kBuffCrashGuard{"BuffCrashGuard", &Config::Patches::tempcrashfixes, InstallBuffCrashGuard};
diff --git a/mods/src/patches/parts/cargo.cc b/mods/src/patches/parts/cargo.cc
new file mode 100644
index 000000000..13623af8f
--- /dev/null
+++ b/mods/src/patches/parts/cargo.cc
@@ -0,0 +1,90 @@
+// Cargo labels: the precision of abbreviated totals (1.25M) and showing the real total at once instead of the
+// count-up animation.
+
+#include "config.h"
+#include "patches/patches.h"
+
+#include "prime/server.h"
+#include "prime/ui.h"
+
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
+#include <spdlog/spdlog.h>
+
+#include <algorithm>
+
+namespace
+{
+// The localization identifier of the "X of Y" cargo label.
+constexpr std::string_view kCargoIdentifier = "shared_x_of_y_x_coloured";
+
+int SignificantDecimals()
+{ return std::clamp(Config::Get().ui.cargo_significant_decimals, 0, 6); }
+
+// m_significantDecimals is read by Localize(), which runs after SetLocalTextParameters, so set it here for good.
+void ColourTextLocalizer_SetLocalTextParameters_Hook(auto original, ColourTextLocalizer* _this, bool parseID,
+                                                     void* args)
+{
+  if (_this && Config::Get().ui.format_cargo_values && _this->IdentifierIs(kCargoIdentifier))
+    _this->SetSignificantDecimals(SignificantDecimals());
+  original(_this, parseID, args);
+}
+
+#if defined(_WIN32) && defined(_M_X64)
+bool IsCargoText(LegacyComparableProgressBar* self)
+{
+  auto* label = self->currentValue_X_of_Y();
+  if (!label || !label->IdentifierIs(kCargoIdentifier))
+    return false;
+  auto* context = self->context();
+  if (!context || context->klass != CargoProgressData::Raw()) {
+    static bool reported = false;
+    if (!reported) {
+      reported = true;
+      spdlog::warn("[InstantCargoText] cargo label has unexpected context {}; native text retained",
+                   context ? il2cpp::ClassName(context->klass) : "null");
+    }
+    return false;
+  }
+  return true;
+}
+
+void SetWidgetData_Hook(auto original, LegacyComparableProgressBar* self)
+{
+  if (!Config::Get().ui.instant_cargo_counter || !self || !IsCargoText(self)) {
+    original(self);
+    return;
+  }
+  // Render the current total through the game's own formatting with the prefab's snap flag set, then restore
+  // the flag so reward updates and interpolation carry on normally.
+  const bool previous = self->snapToValue();
+  self->SetSnapToValue(true);
+  original(self);
+  self->SetSnapToValue(previous);
+}
+#endif
+void InstallInstantCargo()
+{
+  // TODO: Windows x64 only. Enabling it on macOS needs SetWidgetData's prologue checked against SPUD's detour size.
+#if defined(_WIN32) && defined(_M_X64)
+  auto method = LegacyComparableProgressBar::Class::Method("SetWidgetData", 0);
+  // The lookup walks parents; only detour the bar's own override, never the shared Widget`1.SetWidgetData.
+  if (!method || method.Info()->klass != LegacyComparableProgressBar::Class::Raw())
+    return;
+  const bool installed = IL2CPP_HOOK(method, SetWidgetData_Hook) != nullptr;
+  spdlog::info("[InstantCargoText] native text hook {}", installed ? "installed" : "unavailable");
+#else
+  spdlog::info("[InstantCargoText] native text snap is not supported on this platform");
+#endif
+}
+
+void InstallCargoFormat()
+{
+  if (IL2CPP_HOOK(ColourTextLocalizer::Class::Method("SetLocalTextParameters"),
+                  ColourTextLocalizer_SetLocalTextParameters_Hook))
+    spdlog::info("Cargo format: significant decimals = {}", SignificantDecimals());
+}
+} // namespace
+
+const Feature kInstantCargo{"InstantCargo", &Config::Patches::instantcargocounterhooks, InstallInstantCargo};
+const Feature kCargoFormat{"CargoFormat", &Config::Patches::cargoformathooks, InstallCargoFormat};
diff --git a/mods/src/patches/parts/cargo_format.cc b/mods/src/patches/parts/cargo_format.cc
deleted file mode 100644
index ab5092f1e..000000000
--- a/mods/src/patches/parts/cargo_format.cc
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "config.h"
-#include "prime/TextLocalizer.h"
-
-#include <spdlog/spdlog.h>
-#include <spud/detour.h>
-
-// Overrides m_significantDecimals on cargo ColourTextLocalizer instances
-// (identifier "shared_x_of_y_x_coloured"). The field is set permanently in
-// SetLocalTextParameters because Localize(), which reads it, runs later.
-
-static constexpr char  kCargoIdentifier[]   = "shared_x_of_y_x_coloured";
-static constexpr size_t kCargoIdentifierLen = sizeof(kCargoIdentifier) - 1;
-
-void ColourTextLocalizer_SetLocalTextParameters_Hook(auto original, ColourTextLocalizer* _this, bool parseID, void* args)
-{
-  if (!_this || !Config::Get().format_cargo_values) {
-    original(_this, parseID, args);
-    return;
-  }
-
-  int desired_decimals = Config::Get().cargo_significant_decimals;
-  if (desired_decimals < 0) desired_decimals = 0;
-  if (desired_decimals > 6) desired_decimals = 6;
-
-  auto* identifier_ptr = _this->identifier();
-  if (!identifier_ptr) {
-    original(_this, parseID, args);
-    return;
-  }
-
-  // Fast path: compare length then raw UTF-16 chars (ASCII, so low byte only).
-  // Avoids std::string allocation — SetLocalTextParameters fires for every
-  // ColourTextLocalizer in the UI, not just cargo.
-  if ((size_t)identifier_ptr->length != kCargoIdentifierLen) {
-    original(_this, parseID, args);
-    return;
-  }
-  const Il2CppChar* chars = identifier_ptr->chars;
-  for (size_t i = 0; i < kCargoIdentifierLen; ++i) {
-    if ((char)chars[i] != kCargoIdentifier[i]) {
-      original(_this, parseID, args);
-      return;
-    }
-  }
-
-  _this->SetSignificantDecimals(desired_decimals);
-
-  original(_this, parseID, args);
-}
-
-void InstallCargoFormatHooks()
-{
-  auto method = ColourTextLocalizer::Class::Method("SetLocalTextParameters");
-  if (!method) {
-    return;
-  }
-
-  SPUD_STATIC_DETOUR(method.Pointer(), ColourTextLocalizer_SetLocalTextParameters_Hook);
-  int applied = Config::Get().cargo_significant_decimals;
-  if (applied < 0) applied = 0;
-  if (applied > 6) applied = 6;
-  spdlog::info("Cargo format: significant decimals = {}", applied);
-}
diff --git a/mods/src/patches/parts/chat.cc b/mods/src/patches/parts/chat.cc
index de2ea8d18..aa3b49e14 100644
--- a/mods/src/patches/parts/chat.cc
+++ b/mods/src/patches/parts/chat.cc
@@ -1,19 +1,23 @@
-#include "prime/ChatPreviewController.h"
-#include "prime/FullScreenChatViewController.h"
-#include "prime/GenericButtonContext.h"
+// Chat: the shortcuts that open it and switch channel; disable_galaxy_chat and disable_veil_chat, which grey out
+// those tabs in full-screen chat, keep the chat preview off them, and drop their messages from the preview; and
+// default_chat_width and auto_open_chat, which size side chat and open alliance side chat once per login.
 
 #include "config.h"
+#include "patches/chat_startup.h"
+#include "patches/patches.h"
+#include "patches/shortcuts.h"
+
+#include "prime/Hub.h"
+#include "prime/chat.h"
+#include "prime/ui.h"
+
+#include <il2cpp/hook.h>
+#include <spdlog/spdlog.h>
+#include <unity/tracker.h>
 
-#include <spud/detour.h>
-#include <tuple>
 #include <chrono>
 #include <cmath>
-#include <spdlog/spdlog.h>
 #include <stdexcept>
-#include "patches/chat_startup.h"
-#include "patches/screen_update_hook.h"
-#include "prime/Hub.h"
-#include "prime/ScreenManager.h"
 
 namespace
 {
@@ -24,7 +28,7 @@ bool startup_failed = false;
 
 void ObserveChatPreview(ChatPreviewController* preview)
 {
-  if (!Config::Get().auto_open_chat)
+  if (!Config::Get().ui.auto_open_chat)
     return;
   if (preview_handle && preview_handle.Get() == preview)
     return;
@@ -35,12 +39,12 @@ void ObserveChatPreview(ChatPreviewController* preview)
 
 void UpdateChatOptions()
 {
-  const float configured_width = Config::Get().default_chat_width;
+  const float configured_width = Config::Get().ui.default_chat_width;
   const bool custom_width = std::isfinite(configured_width) && configured_width > 0;
-  if (startup_failed || (!Config::Get().auto_open_chat && !custom_width))
+  if (startup_failed || (!Config::Get().ui.auto_open_chat && !custom_width))
     return;
   try {
-    auto* sections = Hub::get_SectionManager();
+    auto* sections = Hub::Sections();
     if (!sections)
       return;
     const auto section = sections->CurrentSection();
@@ -52,7 +56,7 @@ void UpdateChatOptions()
       // notification. A destroyed preview naturally resolves to null.
       return;
     }
-    if ((!Config::Get().auto_open_chat || startup.completed) && (!custom_width || width_applied))
+    if ((!Config::Get().ui.auto_open_chat || startup.completed) && (!custom_width || width_applied))
       return;
     auto* manager = ChatManager::Instance();
     if (!manager)
@@ -68,7 +72,7 @@ void UpdateChatOptions()
         width_applied = true;
       }
     }
-    if (!Config::Get().auto_open_chat || startup.completed)
+    if (!Config::Get().ui.auto_open_chat || startup.completed)
       return;
     auto* preview = preview_handle.Get<ChatPreviewController>();
     const bool station = section == SectionID::Starbase_Interior || section == SectionID::Starbase_Exterior;
@@ -101,153 +105,162 @@ void UpdateChatOptions()
     spdlog::warn("[ChatOptions] disabled after metadata/invocation failure: {}", error.what());
   }
 }
-} // namespace
-
-auto GetChatTabIndices()
-{
-  if (const auto chat_manager = ChatManager::Instance(); chat_manager) {
-    const auto hasCadetChat    = chat_manager->CanSeeNewbieChat();
-    const auto hasVeilChat     = chat_manager->CanSeeRegionalChat();
 
-    const auto galaxyChatIndex = 0 + (hasCadetChat ? 1 : 0);
-    const auto veilChatIndex   = galaxyChatIndex + 1;
-    const auto allianceChatIndex = (hasCadetChat ? 1 : 0) + 1 + (hasVeilChat ? 1 : 0);
+// Tab positions in both the full-screen chat and the preview. Cadet and veil chat only exist for some players,
+// and shift the tabs after them; a missing tab is -1.
+struct ChatTabs {
+  int32_t cadet    = -1;
+  int32_t galaxy   = 0;
+  int32_t veil     = -1;
+  int32_t alliance = 1;
+
+  static ChatTabs Current()
+  {
+    ChatTabs tabs;
+    auto*    chat = ChatManager::Instance();
+    if (!chat)
+      return tabs;
+    const bool cadet = chat->CanSeeNewbieChat();
+    const bool veil  = chat->CanSeeRegionalChat();
+    tabs.cadet       = cadet ? 0 : -1;
+    tabs.galaxy      = cadet ? 1 : 0;
+    tabs.veil        = veil ? tabs.galaxy + 1 : -1;
+    tabs.alliance    = tabs.galaxy + 1 + (veil ? 1 : 0);
+    return tabs;
+  }
 
-    return std::make_tuple(hasCadetChat ? 0 : -1, galaxyChatIndex, hasVeilChat ? veilChatIndex : -1, allianceChatIndex);
+  // Whether `index` is a tab the settings disable.
+  bool Disabled(int32_t index) const
+  {
+    const auto& ui = Config::Get().ui;
+    return (ui.disable_galaxy_chat && index == galaxy) || (ui.disable_veil_chat && veil != -1 && index == veil);
   }
+};
 
-  return std::make_tuple(-1, 0, -1, 1);
-}
+bool AnyDisabled()
+{ return Config::Get().ui.disable_galaxy_chat || Config::Get().ui.disable_veil_chat; }
 
-void DisableButtons(FullScreenChatViewController* _this)
+void FullScreenChatViewController_AboutToShow_Hook(auto original, FullScreenChatViewController* _this)
 {
-  const auto disableGalaxyChat = Config::Get().disable_galaxy_chat;
-  const auto disableVeilChat = Config::Get().disable_veil_chat;
-
-  if (!(disableGalaxyChat || disableVeilChat))
-    return;
-
-  const auto [cadetChatIdx, galaxyChatIdx, veilChatIdx, allianceChatIdx] = GetChatTabIndices();
-
-  const auto viewController = _this->categoriesTabBarViewController();
-  if (!viewController) {
-    return;
-  }
-
-  const auto tabBar = viewController->tabBar();
-  if (!tabBar) {
+  original(_this);
+  if (!AnyDisabled())
     return;
-  }
 
-  const auto listData = tabBar->data();
-  if (!listData) {
+  auto* tab_bar_view = _this->categoriesTabBarViewController();
+  auto* tab_bar      = tab_bar_view ? tab_bar_view->tabBar() : nullptr;
+  auto* buttons      = tab_bar ? tab_bar->data() : nullptr;
+  if (!buttons)
     return;
-  }
-
-  if (disableGalaxyChat) {
-    if (const auto elm = (*listData)[galaxyChatIdx]) {
-      static_cast<GenericButtonContext*>(elm)->SetInteractable(false);
-    }
-  }
-
-  if (disableVeilChat && veilChatIdx != -1) {
-    if (const auto elm = (*listData)[veilChatIdx]) {
-      static_cast<GenericButtonContext*>(elm)->SetInteractable(false);
-    }
-  }
+  const auto tabs = ChatTabs::Current();
+  for (int32_t index : {tabs.galaxy, tabs.veil})
+    if (index >= 0 && index < buttons->Count() && tabs.Disabled(index))
+      if (auto* button = (*buttons)[index])
+        static_cast<GenericButtonContext*>(button)->SetInteractable(false);
 }
 
-void FullScreenChatViewController_AboutToShow(auto original, FullScreenChatViewController* _this)
+// Selecting a disabled tab (with the keyboard, say) does nothing.
+void FullScreenChatViewController_OnDidChangeSelectedTab_Hook(auto original, FullScreenChatViewController* _this,
+                                                              int32_t index, void* tab)
 {
-  original(_this);
-  DisableButtons(_this);
+  if (!ChatTabs::Current().Disabled(index))
+    original(_this, index, tab);
 }
 
-void FullScreenChatViewController_OnDidChangeSelectedTab(auto original, FullScreenChatViewController* _this, int32_t tabIdx, void* tab)
+void FocusAlliance(ChatPreviewController* preview, int32_t alliance)
 {
-  const auto [cadetChatIdx, galaxyChatIdx, veilChatIdx, allianceChatIdx] = GetChatTabIndices();
-  if ((tabIdx == galaxyChatIdx && Config::Get().disable_galaxy_chat) || (tabIdx == veilChatIdx && Config::Get().disable_veil_chat)) {
-    // don't show disabled chats if the associated tab was selected
-    return;
-  }
-
-  original(_this, tabIdx, tab);
+  if (auto* scroller = preview->swipeScroller(); scroller && scroller->currentContentIndex() != alliance)
+    scroller->FocusOnInstantly(alliance);
 }
 
-void ChatPreviewController_AboutToShow(auto original, ChatPreviewController* _this)
+void ChatPreviewController_AboutToShow_Hook(auto original, ChatPreviewController* _this)
 {
   original(_this);
-
   ObserveChatPreview(_this);
-
-  if (Config::Get().disable_galaxy_chat || Config::Get().disable_veil_chat) {
-    const auto allianceChatIdx = std::get<3>(GetChatTabIndices());
+  // The preview reopens on the last panel; move off it only if that channel is disabled.
+  auto*      scroller = _this ? _this->swipeScroller() : nullptr;
+  const auto tabs     = ChatTabs::Current();
+  if (scroller && tabs.Disabled(scroller->currentContentIndex())) {
     _this->SetFocusedPanel(ChatChannelCategory::Alliance);
-
-    if (_this->swipeScroller()->currentContentIndex() != allianceChatIdx) {
-      _this->swipeScroller()->FocusOnInstantly(allianceChatIdx);
-    }
+    FocusAlliance(_this, tabs.alliance);
   }
 }
 
-void ChatPreviewController_OnPanelFocused(auto original, ChatPreviewController* _this, int32_t index)
+void ChatPreviewController_OnPanelFocused_Hook(auto original, ChatPreviewController* _this, int32_t index)
 {
   ObserveChatPreview(_this);
-  static const auto disableGalaxyChat = Config::Get().disable_galaxy_chat;
-  static const auto disableVeilChat   = Config::Get().disable_veil_chat;
-
-  if (!(disableGalaxyChat || disableVeilChat)) {
-    original(_this, index);
-    return;
-  }
-
-  const auto [cadetChatIdx, galaxyChatIdx, veilChatIdx, allianceChatIdx] = GetChatTabIndices();
-  if (disableGalaxyChat || (veilChatIdx != -1 && disableVeilChat)) {
-    _this->SetFocusedPanel(ChatChannelCategory::Alliance);
-    original(_this, allianceChatIdx);
-
-    if (_this->swipeScroller()->currentContentIndex() != allianceChatIdx) {
-      _this->swipeScroller()->FocusOnInstantly(allianceChatIdx);
-    }
-
-    return;
-  }
+  const auto tabs = ChatTabs::Current();
+  if (!tabs.Disabled(index))
+    return original(_this, index);
+  // Swiped onto a disabled channel: focus alliance before the game handles the change, then line the scroller up.
+  _this->SetFocusedPanel(ChatChannelCategory::Alliance);
+  original(_this, tabs.alliance);
+  FocusAlliance(_this, tabs.alliance);
+}
 
-  original(_this, index);
+void ChatPreviewController_OnGlobalMessageReceived_Hook(auto original, ChatPreviewController* _this, void* message)
+{
+  if (!Config::Get().ui.disable_galaxy_chat)
+    original(_this, message);
 }
 
-void ChatPreviewController_OnGlobalMessageReceived(auto original, ChatPreviewController* _this, void* message)
+void ChatPreviewController_OnRegionalMessageReceived_Hook(auto original, ChatPreviewController* _this, void* message)
 {
-  if (Config::Get().disable_galaxy_chat)
-    return;
+  if (!Config::Get().ui.disable_veil_chat)
+    original(_this, message);
+}
 
-  original(_this, message);
+void InstallChat()
+{
+  spdlog::info("[ChatOptions] lifecycle v2 registered: auto_open={} width={}", Config::Get().ui.auto_open_chat,
+               Config::Get().ui.default_chat_width);
+  IL2CPP_HOOK(FullScreenChatViewController::Class::Method("AboutToShow"),
+              FullScreenChatViewController_AboutToShow_Hook);
+  IL2CPP_HOOK(FullScreenChatViewController::Class::Method("OnDidChangeSelectedTab"),
+              FullScreenChatViewController_OnDidChangeSelectedTab_Hook);
+  IL2CPP_HOOK(ChatPreviewController::Class::Method("AboutToShow"), ChatPreviewController_AboutToShow_Hook);
+  IL2CPP_HOOK(ChatPreviewController::Class::Method("OnPanelFocused"), ChatPreviewController_OnPanelFocused_Hook);
+  IL2CPP_HOOK(ChatPreviewController::Class::Method("OnGlobalMessageReceived"),
+              ChatPreviewController_OnGlobalMessageReceived_Hook);
+  IL2CPP_HOOK(ChatPreviewController::Class::Method("OnRegionalMessageReceived"),
+              ChatPreviewController_OnRegionalMessageReceived_Hook);
 }
+} // namespace
 
-void ChatPreviewController_OnRegionalMessageReceived(auto original, ChatPreviewController* _this, void* message)
+void OpenChatShortcut()
 {
-  if (Config::Get().disable_veil_chat)
+  const bool side = Shortcut::IsDown(Action::kShowChatSide1) || Shortcut::IsDown(Action::kShowChatSide2);
+  if (!side && !Shortcut::IsDown(Action::kShowChat))
+    return;
+  auto* chat = ChatManager::Instance();
+  if (!chat)
     return;
 
-  original(_this, message);
+  // With side chat already open, the shortcut focuses its input instead.
+  if (chat->IsSideChatOpen()) {
+    auto* view  = unity::Newest<FullScreenChatViewController>();
+    auto* list  = view ? view->messageList() : nullptr;
+    auto* input = list ? list->inputField() : nullptr;
+    if (input)
+      input->ActivateInputField();
+  } else {
+    chat->OpenChannel(ChatChannelCategory::Alliance, side ? ChatViewMode::Side : ChatViewMode::Fullscreen);
+  }
 }
 
-void InstallChatPatches()
+bool ChatChannelShortcuts()
 {
-  if (install_screen_manager_update_hook() && register_screen_manager_update_callback(UpdateChatOptions))
-    spdlog::info("[ChatOptions] lifecycle v2 registered: auto_open={} width={}",
-                 Config::Get().auto_open_chat, Config::Get().default_chat_width);
-  if (auto m = FullScreenChatViewController::Class::Method("AboutToShow"))
-    SPUD_STATIC_DETOUR(m.Pointer(), FullScreenChatViewController_AboutToShow);
-  if (auto m = FullScreenChatViewController::Class::Method("OnDidChangeSelectedTab"))
-    SPUD_STATIC_DETOUR(m.Pointer(), FullScreenChatViewController_OnDidChangeSelectedTab);
-
-  if (auto m = ChatPreviewController::Class::Method("AboutToShow"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ChatPreviewController_AboutToShow);
-  if (auto m = ChatPreviewController::Class::Method("OnPanelFocused"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ChatPreviewController_OnPanelFocused);
-  if (auto m = ChatPreviewController::Class::Method("OnGlobalMessageReceived"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ChatPreviewController_OnGlobalMessageReceived);
-  if (auto m = ChatPreviewController::Class::Method("OnRegionalMessageReceived"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ChatPreviewController_OnRegionalMessageReceived);
+  auto* chat = ChatManager::Instance();
+  if (!chat)
+    return false;
+  for (auto [shortcut, channel] : {std::pair{Action::kSelectChatGlobal, ChatChannelCategory::Global},
+                                   std::pair{Action::kSelectChatAlliance, ChatChannelCategory::Alliance},
+                                   std::pair{Action::kSelectChatPrivate, ChatChannelCategory::Private}}) {
+    if (Shortcut::IsDown(shortcut)) {
+      chat->OpenChannel(channel);
+      return true;
+    }
+  }
+  return false;
 }
+
+const Feature kChat{"Chat", &Config::Patches::chatpatches, InstallChat, UpdateChatOptions};
diff --git a/mods/src/patches/parts/chat_titles.cc b/mods/src/patches/parts/chat_titles.cc
index 2e97e6cba..d024167f6 100644
--- a/mods/src/patches/parts/chat_titles.cc
+++ b/mods/src/patches/parts/chat_titles.cc
@@ -1,28 +1,16 @@
-#include "prime/ChatMessageWidget.h"
-#include "prime/GameObject.h"
-#include "prime/UserProfileWidget.h"
+#include "patches/patches.h"
+#include "prime/chat.h"
+#include <unity/core.h>
 
 #include "config.h"
-#include "errormsg.h"
 #include "patches/native_hook_extent.h"
 
-#include <il2cpp/il2cpp-functions.h>
-#include <il2cpp/il2cpp_helper.h>
+#include <il2cpp/hook.h>
 
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
 
 namespace
 {
-Il2CppObject* InvokeSelf(Il2CppObject* object, const char* method_name)
-{
-  auto* method = il2cpp_class_get_method_from_name(object ? il2cpp_object_get_class(object) : nullptr, method_name, 0);
-  if (!method) {
-    return nullptr;
-  }
-  Il2CppException* exception = nullptr;
-  return (Il2CppObject*)il2cpp_runtime_invoke(method, object, nullptr, &exception);
-}
 bool IsChatRow(void* profile_widget)
 {
   auto* mb = (Il2CppObject*)profile_widget;
@@ -30,26 +18,27 @@ bool IsChatRow(void* profile_widget)
     return false;
   }
 
-  auto* transform = InvokeSelf(mb, "get_transform");
+  auto* transform = reinterpret_cast<il2cpp::Object*>(mb)->As<unity::Component>()->transform();
   if (!transform) {
     return false;
   }
 
   for (int hops = 0; hops < 32 && transform; ++hops) {
-    auto* gameObject = InvokeSelf(transform, "get_gameObject");
+    auto* gameObject = transform->gameObject();
     if (!gameObject) {
       return false;
     }
-    if (reinterpret_cast<GameObject*>(gameObject)->GetComponent<ChatMessageWidget>()) {
+    if (reinterpret_cast<unity::GameObject*>(gameObject)->GetComponent<ChatMessageWidget>()) {
       return true;
     }
-    transform = InvokeSelf(transform, "get_parent");
+    transform = transform->parent();
   }
   return false;
 }
 void HideTitleRow(void* title)
 {
-  auto* game_object = reinterpret_cast<GameObject*>(InvokeSelf(static_cast<Il2CppObject*>(title), "get_gameObject"));
+  auto* game_object = reinterpret_cast<unity::GameObject*>(
+      reinterpret_cast<il2cpp::Object*>(title)->As<unity::Component>()->gameObject());
   if (!game_object) {
     return;
   }
@@ -63,7 +52,7 @@ void ApplyTitleDisplay(void* profile_widget)
     return;
   }
 
-  const auto show  = Config::Get().show_player_title;
+  const auto show  = Config::Get().ui.show_player_title;
   auto*      title = widget->playerTitleWidget();
   if (show || title == nullptr) {
     return;
@@ -89,17 +78,17 @@ void PlayerTitleWidget_BindPath_Hook(auto original, void* _this)
 {
   original(_this);
   try {
-    if (Config::Get().show_player_title) {
+    if (Config::Get().ui.show_player_title) {
       return;
     }
     UserProfileWidget* owner     = nullptr;
-    auto*              transform = InvokeSelf((Il2CppObject*)_this, "get_transform");
+    auto*              transform = reinterpret_cast<il2cpp::Object*>(_this)->As<unity::Component>()->transform();
     for (int hops = 0; hops < 32 && transform && !owner; ++hops) {
-      auto* gameObject = reinterpret_cast<GameObject*>(InvokeSelf(transform, "get_gameObject"));
+      auto* gameObject = reinterpret_cast<unity::GameObject*>(transform->gameObject());
       if (gameObject) {
         owner = gameObject->GetComponent<UserProfileWidget>();
       }
-      transform = InvokeSelf(transform, "get_parent");
+      transform = transform->parent();
     }
     if (owner) {
       ApplyTitleDisplay(owner);
@@ -135,30 +124,16 @@ void* ValidateDetourTarget(void* entry, const char* name)
 #endif
 } // namespace
 
+namespace
+{
 void InstallChatTitleDisplayHooks()
 {
-  void* update_player_title = nullptr;
-  if (auto profile_widget =
-          il2cpp_get_class_helper("Assembly-CSharp", "Digit.Prime.PlayerProfile", "UserProfileWidget");
-      !profile_widget.isValidHelper()) {
-    spdlog::warn("Missing class {}.{}", "Digit.Prime.PlayerProfile", "UserProfileWidget");
-  } else if ((update_player_title = profile_widget.GetMethod("UpdatePlayerTitle", 0)) == nullptr) {
-    spdlog::warn("Missing method {}.{}", "UserProfileWidget", "UpdatePlayerTitle");
-  }
-
-  void* set_widget_data     = nullptr;
-  void* on_did_bind_context = nullptr;
-  if (auto title_widget = il2cpp_get_class_helper("Assembly-CSharp", "Digit.Prime.PlayerAvatars", "PlayerTitleWidget");
-      !title_widget.isValidHelper()) {
-    spdlog::warn("Missing class {}.{}", "Digit.Prime.PlayerAvatars", "PlayerTitleWidget");
-  } else {
-    set_widget_data     = title_widget.GetMethod("SetWidgetData", 0);
-    on_did_bind_context = title_widget.GetMethod("OnDidBindContext", 0);
-    if (!set_widget_data || !on_did_bind_context) {
-      spdlog::warn("Missing method {}.{}", "PlayerTitleWidget", set_widget_data ? "OnDidBindContext" : "SetWidgetData");
-      set_widget_data     = nullptr;
-      on_did_bind_context = nullptr;
-    }
+  void* update_player_title = UserProfileWidget::Class::Method("UpdatePlayerTitle", 0).Pointer();
+  void* set_widget_data     = PlayerTitleWidget::Class::Method("SetWidgetData", 0).Pointer();
+  void* on_did_bind_context = PlayerTitleWidget::Class::Method("OnDidBindContext", 0).Pointer();
+  if (!set_widget_data || !on_did_bind_context) {
+    set_widget_data     = nullptr;
+    on_did_bind_context = nullptr;
   }
 
   if (!update_player_title && !set_widget_data && !on_did_bind_context) {
@@ -189,22 +164,26 @@ void InstallChatTitleDisplayHooks()
                  "keeping one detour");
     set_widget_data = nullptr;
   }
-  if (on_did_bind_context
-      && (on_did_bind_context == update_player_title || on_did_bind_context == set_widget_data)) {
+  if (on_did_bind_context && (on_did_bind_context == update_player_title || on_did_bind_context == set_widget_data)) {
     spdlog::info("[ChatTitleDisplay] OnDidBindContext shares its native implementation with another target; "
                  "keeping one detour");
     on_did_bind_context = nullptr;
   }
 
   if (update_player_title) {
-    SPUD_STATIC_DETOUR(update_player_title, UserProfileWidget_UpdatePlayerTitle_Hook);
+    IL2CPP_DETOUR(update_player_title, UserProfileWidget_UpdatePlayerTitle_Hook,
+                  "UserProfileWidget_UpdatePlayerTitle_Hook");
   }
   if (set_widget_data) {
-    SPUD_STATIC_DETOUR(set_widget_data, PlayerTitleWidget_BindPath_Hook);
+    IL2CPP_DETOUR(set_widget_data, PlayerTitleWidget_BindPath_Hook, "PlayerTitleWidget_BindPath_Hook");
   }
   if (on_did_bind_context) {
-    SPUD_STATIC_DETOUR(on_did_bind_context, PlayerTitleWidget_BindPath_Hook);
+    IL2CPP_DETOUR(on_did_bind_context, PlayerTitleWidget_BindPath_Hook, "PlayerTitleWidget_BindPath_Hook");
   }
 
-  spdlog::info("Chat title display: chat player title rows {}", Config::Get().show_player_title ? "shown" : "hidden");
+  spdlog::info("Chat title display: chat player title rows {}",
+               Config::Get().ui.show_player_title ? "shown" : "hidden");
 }
+} // namespace
+
+const Feature kChatTitles{"ChatTitles", &Config::Patches::chattitledisplayhooks, InstallChatTitleDisplayHooks};
diff --git a/mods/src/patches/parts/daily_faction_bulk_claim.cc b/mods/src/patches/parts/daily_faction_bulk_claim.cc
index 426c9cba4..f846553ba 100644
--- a/mods/src/patches/parts/daily_faction_bulk_claim.cc
+++ b/mods/src/patches/parts/daily_faction_bulk_claim.cc
@@ -1,290 +1,197 @@
+// Missions: the hud_* settings, which force mission HUD buttons always shown or never shown, and
+// daily_bulk_claim_factions and daily_bulk_claim_toggle_default_on, which limit the missions screen's Claim All to
+// the chosen factions' dailies, show only their icons next to the toggle, and can switch the toggle on.
+
 #include "config.h"
+#include "patches/patches.h"
 #include "str_utils.h"
 
-#include <prime/Component.h>
-#include <prime/EventSystem.h>
-#include <prime/GameObject.h>
-#include <prime/Transform.h>
+#include "prime/hud.h"
+#include "prime/missions.h"
 
+#include <il2cpp/hook.h>
 #include <il2cpp/il2cpp.h>
-#include <spud/detour.h>
-
-#include <spdlog/fmt/ranges.h>
 #include <spdlog/spdlog.h>
+#include <unity/ui.h>
 
 #include <algorithm>
 #include <string>
 
 namespace
 {
-constexpr std::string_view kFactionPointResourcePrefix = "Resource_FactionPoint_";
-
-struct ResourceSpec : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "ResourceSpec">;
-
-  Il2CppString* resourceId()
-  { return Field<"resourceId_", Il2CppString*>(); }
-};
-
-struct InventoryItem : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "InventoryItem">;
+// --- Mission HUD buttons ---
 
-  ResourceSpec* resourceSpec()
-  { return Field<"_resourceSpec", ResourceSpec*>(); }
-};
-
-struct PointerEventData : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.EventSystems", "PointerEventData">;
-};
+using ButtonGetter = unity::Component* (*)(MissionsHudViewController*);
 
-struct Toggle : Component {
-  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.UI", "Toggle">;
+template <il2cpp::Name Field> unity::Component* HudButton(MissionsHudViewController* controller)
+{ return controller->ButtonField<Field>(); }
 
-  bool isOn()
-  { return Get<"isOn", bool>(); }
-  void OnPointerClick(PointerEventData* event)
-  { Call<"OnPointerClick">(event); }
-
-  // Goes through the pointer handler instead of the isOn setter, so interactable checks and
-  // listeners behave as for a real click.
-  void SimulateClick()
-  {
-    if (auto* event = il2cpp::New<PointerEventData>(EventSystem::current()))
-      OnPointerClick(event);
-  }
+struct ButtonSetting {
+  const char*  name; // the hud_<name> setting
+  ButtonGetter button;
 };
 
-struct MissionViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Missions", "MissionViewController">;
-
-  Toggle* ClaimAllToggle()
-  { return Field<"_claimAllToggle", Toggle*>(); }
+constexpr ButtonSetting kButtons[] = {
+    {"q_trials", HudButton<"_challengesButton">}, {"field_training", HudButton<"_achievementsButton">},
+    {"outposts", HudButton<"_outpostsButton">},   {"daily_goals", HudButton<"_dailyGoalsButton">},
+    {"missions", HudButton<"_missionsButton">},
 };
 
-// GetClaimableDailiesList returns List<ITournament>; the items are EventModel today.
-using TournamentList = il2cpp::List<il2cpp::Object*>;
-
-Transform* GetTransformOf(Component* component)
-{ return component ? component->transform() : nullptr; }
-
-Transform* FindChildByName(Transform* root, const char* name)
+// The game decides visibility here; the hud_* settings are applied on top every time it does.
+int32_t MissionsHudViewController_UpdateButtons_Hook(auto original, MissionsHudViewController* _this)
 {
-  if (root == nullptr) {
-    return nullptr;
-  }
-
-  auto* go = root->gameObject();
-  if (go != nullptr && go->Name() == name) {
-    return root;
+  const auto  result = original(_this);
+  const auto& ui     = Config::Get().ui;
+  for (const auto& button : kButtons) {
+    const auto visibility = ui.MissionHudButtonVisibility(button.name);
+    if (visibility == MissionHudVisibility::kAuto)
+      continue;
+    auto* component = button.button(_this);
+    if (auto* object = component ? component->gameObject() : nullptr)
+      object->SetActive(visibility == MissionHudVisibility::kAlways);
   }
+  return result;
+}
 
-  for (int32_t i = 0; i < root->childCount(); ++i) {
-    if (auto* found = FindChildByName(root->GetChild(i), name)) {
-      return found;
-    }
-  }
+// --- Daily faction claims ---
 
-  return nullptr;
-}
+using DailyGoalList = il2cpp::List<DailyGoal*>;
 
-struct FactionIconName {
-  const char* faction;
-  const char* game_object_name;
+struct Faction {
+  const char* name; // as in daily_bulk_claim_factions
+  const char* icon; // the GameObject next to the Claim All toggle
 };
 
-constexpr FactionIconName kFactionIconNames[] = {
+constexpr Faction kFactions[] = {
     {"federation", "Fed_Icon"},
     {"romulan", "Rom_Icon"},
     {"klingon", "Klg_Icon"},
 };
 
-void ApplyFactionIconVisibility(Transform* toggle_tf)
-{
-  if (toggle_tf == nullptr) {
-    return;
-  }
-
-  auto* parent = toggle_tf->parent();
-  if (parent == nullptr) {
-    spdlog::debug("[DailyFactionBulkClaim] ApplyFactionIconVisibility: toggle has no parent Transform");
-    return;
-  }
-
-  const auto& configured = Config::Get().daily_bulk_claim_factions;
-
-  for (const auto& entry : kFactionIconNames) {
-    auto* icon_transform = FindChildByName(parent, entry.game_object_name);
-    if (icon_transform == nullptr) {
-      spdlog::debug("[DailyFactionBulkClaim] ApplyFactionIconVisibility: '{}' not found", entry.game_object_name);
-      continue;
-    }
-
-    auto* go = icon_transform->gameObject();
-    if (go == nullptr) {
-      continue;
-    }
-
-    const bool should_show =
-        configured.empty() || std::ranges::find(configured, std::string(entry.faction)) != configured.end();
-    go->SetActive(should_show);
-  }
-}
-
-bool                   g_applied_default_toggle_on      = false;
-int                    g_default_toggle_attempts        = 0;
-MissionViewController* g_active_mission_view_controller = nullptr;
-
-constexpr int kMaxDefaultToggleAttempts = 300;
-
-void ApplyDefaultToggleOnOnce(MissionViewController* controller)
+bool Claimed(std::string_view faction)
 {
-  auto* toggle = controller != nullptr ? controller->ClaimAllToggle() : nullptr;
-  if (g_applied_default_toggle_on || !Config::Get().daily_bulk_claim_toggle_default_on || toggle == nullptr) {
-    return;
-  }
-
-  if (toggle->isOn()) {
-    g_applied_default_toggle_on = true;
-    return;
-  }
-
-  if (++g_default_toggle_attempts > kMaxDefaultToggleAttempts) {
-    spdlog::warn("[DailyFactionBulkClaim] daily_bulk_claim_toggle_default_on: giving up, toggle never became "
-                "interactable");
-    g_applied_default_toggle_on = true;
-    return;
-  }
-
-  toggle->SimulateClick();
-
-  if (toggle->isOn()) {
-    spdlog::debug("[DailyFactionBulkClaim] daily_bulk_claim_toggle_default_on: forced Claim All toggle on "
-                 "(attempt {})",
-                 g_default_toggle_attempts);
-    g_applied_default_toggle_on = true;
-  }
+  const auto& factions = Config::Get().ui.daily_bulk_claim_factions;
+  return factions.empty() || std::ranges::find(factions, faction) != factions.end();
 }
 
-bool FactionMatches(const std::string& faction_name, const std::vector<std::string>& configured)
+unity::Transform* FindChild(unity::Transform* root, std::string_view name)
 {
-  if (faction_name.empty() || configured.empty()) {
-    return false;
-  }
-  return std::ranges::find(configured, AsciiStrToLower(faction_name)) != configured.end();
+  if (!root)
+    return nullptr;
+  if (auto* object = root->gameObject(); object && object->Name() == name)
+    return root;
+  for (int32_t i = 0; i < root->childCount(); ++i)
+    if (auto* found = FindChild(root->GetChild(i), name))
+      return found;
+  return nullptr;
 }
 
-bool IsMainFactionDaily(const std::string& faction_name)
+void ShowClaimedFactionIcons(MissionViewController* controller)
 {
-  if (faction_name.empty()) {
-    return false;
+  auto* toggle = controller->claimAllToggle();
+  auto* parent = toggle && toggle->transform() ? toggle->transform()->parent() : nullptr;
+  if (!parent)
+    return;
+  for (const auto& faction : kFactions) {
+    auto* icon   = FindChild(parent, faction.icon);
+    auto* object = icon ? icon->gameObject() : nullptr;
+    if (object)
+      object->SetActive(Claimed(faction.name));
+    else
+      spdlog::debug("[DailyFactionBulkClaim] icon '{}' not found", faction.icon);
   }
-  const auto lowered = AsciiStrToLower(faction_name);
-  return std::ranges::any_of(kFactionIconNames, [&](const auto& entry) { return lowered == entry.faction; });
 }
 
-std::string FactionNameOfTournament(il2cpp::Object* tournament)
+// The faction whose points a daily rewards, lower-cased ("federation"), or empty for other dailies.
+std::string FactionOf(DailyGoal* daily)
 {
-  auto* rewards = tournament ? tournament->Field<"_factionPointRewards", il2cpp::List<InventoryItem*>*>() : nullptr;
+  constexpr std::string_view kPrefix = "Resource_FactionPoint_";
+  auto*                      rewards = daily ? daily->factionPointRewards() : nullptr;
   if (!rewards)
     return {};
-
   for (auto* item : *rewards) {
-    auto* spec   = item ? item->resourceSpec() : nullptr;
-    auto* id_str = spec ? spec->resourceId() : nullptr;
-    if (id_str == nullptr) {
-      continue;
-    }
-
-    auto resource_id = to_string(id_str);
-    if (resource_id.starts_with(kFactionPointResourcePrefix)) {
-      return resource_id.substr(kFactionPointResourcePrefix.size());
-    }
+    auto* spec = item ? item->resourceSpec() : nullptr;
+    auto* id   = spec ? spec->resourceId() : nullptr;
+    if (auto resource = id ? il2cpp::ToUtf8(id) : std::string(); resource.starts_with(kPrefix))
+      return AsciiStrToLower(resource.substr(kPrefix.size()));
   }
-
   return {};
 }
 
-void FilterClaimableDailiesByFaction(TournamentList* list, const std::vector<std::string>& configured)
+DailyGoalList* MissionViewController_GetClaimableDailiesList_Hook(auto original, MissionViewController* _this)
 {
-  if (list == nullptr) {
-    spdlog::debug("[DailyFactionBulkClaim] GetClaimableDailiesList returned null; nothing to filter");
-    return;
-  }
+  auto* list = original(_this);
+  ShowClaimedFactionIcons(_this);
+  if (!list || Config::Get().ui.daily_bulk_claim_factions.empty())
+    return list;
 
+  // Only the three main factions' dailies are filtered; anything else is always claimed.
   const auto total = list->Count();
-  spdlog::debug("[DailyFactionBulkClaim] filtering {} claimable daily(ies) against configured factions [{}]", total,
-               fmt::join(configured, ", "));
-
-  int kept = 0;
   for (int32_t i = total - 1; i >= 0; --i) {
-    auto* tournament    = (*list)[i];
-    auto  faction_name  = FactionNameOfTournament(tournament);
-    const bool is_main_faction_daily = IsMainFactionDaily(faction_name);
-    auto  matches       = FactionMatches(faction_name, configured);
-
-    spdlog::debug("[DailyFactionBulkClaim]   [{}] faction: '{}' -> {}", i,
-                 faction_name.empty() ? "<none>" : faction_name,
-                 !is_main_faction_daily ? "keep (not a main faction daily)"
-                                        : (matches ? "keep (claim)" : "remove (skip)"));
-
-    if (is_main_faction_daily && !matches) {
+    const auto faction = FactionOf((*list)[i]);
+    const bool main    = std::ranges::any_of(kFactions, [&](const Faction& f) { return faction == f.name; });
+    if (main && !Claimed(faction))
       list->RemoveAt(i);
-    } else {
-      ++kept;
-    }
   }
-
-  spdlog::debug("[DailyFactionBulkClaim] kept {}/{} daily(ies) for claiming", kept, total);
+  spdlog::debug("[DailyFactionBulkClaim] claiming {} of {} dailies", list->Count(), total);
+  return list;
 }
 
-TournamentList* MissionViewController_GetClaimableDailiesList(auto original, MissionViewController* _this)
-{
-  auto* list = original(_this);
-
-  ApplyFactionIconVisibility(GetTransformOf(_this->ClaimAllToggle()));
+// daily_bulk_claim_toggle_default_on flips the toggle once per session. The toggle is not interactable straight
+// away, so the frame tick keeps trying while the missions screen is open, for at most kMaxToggleAttempts frames.
+constexpr int kMaxToggleAttempts = 300;
 
-  const auto& configured = Config::Get().daily_bulk_claim_factions;
-  if (configured.empty()) {
-    return list;
-  }
+MissionViewController* shown_controller = nullptr;
+bool                   toggle_done      = false;
+int                    toggle_attempts  = 0;
 
-  FilterClaimableDailiesByFaction(list, configured);
-  return list;
+void MissionViewController_AboutToShow_Hook(auto original, MissionViewController* _this)
+{
+  original(_this);
+  ShowClaimedFactionIcons(_this);
+  shown_controller = _this;
 }
 
-void MissionViewController_AboutToShow(auto original, MissionViewController* _this)
+void MissionViewController_AboutToHide_Hook(auto original, MissionViewController* _this)
 {
+  if (shown_controller == _this)
+    shown_controller = nullptr;
   original(_this);
-
-  ApplyFactionIconVisibility(GetTransformOf(_this->ClaimAllToggle()));
-
-  g_active_mission_view_controller = _this;
 }
 
-void MissionViewController_AboutToHide(auto original, MissionViewController* _this)
+void MissionsUpdate()
 {
-  if (g_active_mission_view_controller == _this) {
-    g_active_mission_view_controller = nullptr;
+  if (!shown_controller || toggle_done || !Config::Get().ui.daily_bulk_claim_toggle_default_on)
+    return;
+  auto* toggle = shown_controller->claimAllToggle();
+  if (!toggle)
+    return;
+  if (!toggle->isOn()) {
+    if (++toggle_attempts > kMaxToggleAttempts) {
+      spdlog::warn("[DailyFactionBulkClaim] Claim All toggle never became interactable; not switching it on");
+      toggle_done = true;
+      return;
+    }
+    toggle->SimulateClick();
   }
-
-  original(_this);
+  toggle_done = toggle->isOn();
 }
-} // namespace
 
-void DailyFactionBulkClaimUpdate()
+void InstallMissionHud()
 {
-  if (g_active_mission_view_controller != nullptr) {
-    ApplyDefaultToggleOnOnce(g_active_mission_view_controller);
-  }
+  IL2CPP_HOOK(MissionsHudViewController::Class::Method("UpdateButtons", 0),
+              MissionsHudViewController_UpdateButtons_Hook);
 }
 
-void InstallDailyFactionBulkClaimHooks()
+void InstallDailyClaimFilter()
 {
   using Controller = MissionViewController::Class;
-  if (auto m = Controller::Method("GetClaimableDailiesList", 0))
-    SPUD_STATIC_DETOUR(m.Pointer(), MissionViewController_GetClaimableDailiesList);
-  if (auto m = Controller::Method("AboutToShow", 0))
-    SPUD_STATIC_DETOUR(m.Pointer(), MissionViewController_AboutToShow);
-  if (auto m = Controller::Method("AboutToHide", 0))
-    SPUD_STATIC_DETOUR(m.Pointer(), MissionViewController_AboutToHide);
+  IL2CPP_HOOK(Controller::Method("GetClaimableDailiesList", 0), MissionViewController_GetClaimableDailiesList_Hook);
+  IL2CPP_HOOK(Controller::Method("AboutToShow", 0), MissionViewController_AboutToShow_Hook);
+  IL2CPP_HOOK(Controller::Method("AboutToHide", 0), MissionViewController_AboutToHide_Hook);
 }
+} // namespace
+
+const Feature kMissionHud{"MissionHud", &Config::Patches::missionhudtweakshooks, InstallMissionHud};
+const Feature kDailyClaimFilter{"DailyClaimFilter", &Config::Patches::dailyfactionbulkclaimhooks,
+                                InstallDailyClaimFilter, MissionsUpdate};
diff --git a/mods/src/patches/parts/daily_faction_bulk_claim.h b/mods/src/patches/parts/daily_faction_bulk_claim.h
deleted file mode 100644
index 46f646b60..000000000
--- a/mods/src/patches/parts/daily_faction_bulk_claim.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-
-void DailyFactionBulkClaimUpdate();
-
-void InstallDailyFactionBulkClaimHooks();
diff --git a/mods/src/patches/parts/disable_banners.cc b/mods/src/patches/parts/disable_banners.cc
deleted file mode 100644
index e7be0daf1..000000000
--- a/mods/src/patches/parts/disable_banners.cc
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "config.h"
-#include "patches/notification_service.h"
-
-#include <il2cpp/il2cpp.h>
-#include <prime/Toast.h>
-
-#include <spud/detour.h>
-
-struct ToastObserver : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "ToastObserver">;
-};
-
-void ToastObserver_EnqueueToast_Hook(auto original, ToastObserver *_this, Toast *toast)
-{
-  notification_handle_toast(toast);
-
-  if (std::ranges::find(Config::Get().disabled_banner_types, toast->get_State())
-      != Config::Get().disabled_banner_types.end()) {
-    return;
-  }
-
-  original(_this, toast);
-}
-
-void ToastObserver_EnqueueOrCombineToast_Hook(auto original, ToastObserver *_this, Toast *toast, uintptr_t cmpAction)
-{
-  notification_handle_toast(toast);
-
-  if (std::ranges::find(Config::Get().disabled_banner_types, toast->get_State())
-      != Config::Get().disabled_banner_types.end()) {
-    return;
-  }
-
-  original(_this, toast, cmpAction);
-}
-
-void InstallToastBannerHooks()
-{
-  notification_init();
-
-  if (auto m = ToastObserver::Class::Method("EnqueueToast"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ToastObserver_EnqueueToast_Hook);
-  if (auto m = ToastObserver::Class::Method("EnqueueOrCombineToast"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ToastObserver_EnqueueOrCombineToast_Hook);
-}
diff --git a/mods/src/patches/parts/double_click_assign_ship.cc b/mods/src/patches/parts/double_click_assign_ship.cc
index 9a2058d8a..c9a1507e5 100644
--- a/mods/src/patches/parts/double_click_assign_ship.cc
+++ b/mods/src/patches/parts/double_click_assign_ship.cc
@@ -1,40 +1,125 @@
-#include "config.h"
-#include "patches/key.h"
-#include "patches/object_tracker.h"
+// The ship management dock: pinned_ships, which moves the named ships to the front of the idle ship list after the
+// game sorts it, and double_click_to_assign_ship, where a double click on a ship tile or Enter presses Assign.
+//
+// Only ShipManagementViewContext.Sort is hooked, not ISortedFleetsContext, so the hailing frequencies inventory keeps
+// the game's order.
 
-#include "double_click_assign_ship.h"
-#include "prime/AssignShipsWidget.h"
-#include "prime/CanvasController.h"
-#include "prime/KeyCode.h"
+#include "config.h"
+#include "patches/patches.h"
 #include "ship_tile_click.h"
+#include "str_utils.h"
 
+#include "prime/fleet.h"
+#include "prime/ui.h"
+
+#include <il2cpp/hook.h>
 #include <il2cpp/il2cpp.h>
-#include "patches/object_tracker.h"
+#include <spdlog/fmt/ranges.h>
+#include <spdlog/spdlog.h>
+#include <unity/input.h>
+#include <unity/tracker.h>
 
+#include <algorithm>
 #include <chrono>
+#include <set>
+#include <string>
+#include <vector>
 
-namespace {
+namespace
+{
+// --- Pinned ships ---
 
-constexpr auto kDoubleClickWindow = std::chrono::milliseconds(400);
+// Unmatched entries are warned about once, not on every sort.
+std::set<std::string> warned;
 
-FleetPlayerData*                      g_last_clicked_ship = nullptr;
-std::chrono::steady_clock::time_point g_last_click_time{};
+// Within the pinned group and the rest, the game's active sort order is kept.
+void PinShips(il2cpp::List<FleetPlayerData*>* list)
+{
+  const auto& pinned = Config::Get().ui.pinned_ships;
+  const auto  count  = list ? list->Count() : 0;
+  if (pinned.empty() || count <= 1)
+    return;
+  if (count > 2000) {
+    spdlog::warn("[PinnedShipSort] SortedIdleShips reported an implausible count ({}); skipping", count);
+    return;
+  }
 
-void PressAssignButton()
+  struct Ship {
+    FleetPlayerData*         data;
+    std::vector<std::string> words;
+    int64_t                  level;
+    bool                     pinned = false;
+    int8_t                   tech_applied = -1;
+
+    bool TechApplied()
+    {
+      if (tech_applied < 0)
+        tech_applied = data && data->HasAppliedTech() ? 1 : 0;
+      return tech_applied == 1;
+    }
+  };
+  std::vector<Ship> ships;
+  ships.reserve(count);
+  for (auto* ship : *list)
+    ships.push_back(
+        {ship, ship ? ShipNameWords(ship->DisplayName()) : std::vector<std::string>(), ship ? ship->Level() : 0});
+
+  // Each entry pins one ship: the highest-level idle ship it matches that an earlier entry has not taken.
+  bool any = false;
+  for (const auto& pattern : pinned) {
+    Ship* best = nullptr;
+    for (auto& ship : ships)
+      if (!ship.pinned && ShipNameMatches(ship.words, pattern)
+          && (!best || ship.level > best->level
+              || (ship.level == best->level && ship.data && best->data && ship.data->HullId() == best->data->HullId()
+                  && ship.TechApplied() && !best->TechApplied())))
+        best = &ship;
+    if (best) {
+      best->pinned = any = true;
+    } else if (const auto name = fmt::format("{}", fmt::join(pattern, " ")); warned.insert(name).second) {
+      spdlog::warn("[PinnedShipSort] pinned_ships entry '{}' matched no idle ship (entries match the end of the "
+                   "game's own ship name)",
+                   name);
+    }
+  }
+  if (!any)
+    return;
+
+  std::ranges::stable_partition(ships, &Ship::pinned);
+  bool unchanged = true;
+  for (int32_t i = 0; i < count && unchanged; ++i)
+    unchanged = ships[i].data == (*list)[i];
+  if (unchanged)
+    return;
+
+  // SortedIdleShips is a List<T>, which always has Clear and Add; the rewrite cannot stop halfway.
+  list->Clear();
+  for (const auto& ship : ships)
+    list->Add(ship.data);
+}
+
+void ShipManagementViewContext_Sort_Hook(auto original, ShipManagementViewContext* _this)
 {
-  for (auto widget : ObjectFinder<AssignShipsWidget>::GetAll()) {
-    if (!widget) continue;
+  original(_this);
+  PinShips(_this->SortedIdleShips());
+}
+
+// --- Double click to assign ---
+
+constexpr auto kDoubleClickWindow = std::chrono::milliseconds(400);
 
-    auto canvas = GetCanvasControllerFromComponent(widget);
-    if (!canvas || !canvas->Visible() || !widget->isActiveAndEnabled()) continue;
+FleetPlayerData*                      last_clicked_ship = nullptr;
+std::chrono::steady_clock::time_point last_click_time{};
 
-    auto* buttonWrapper = widget->assignButton();
-    auto* buttonWidget  = buttonWrapper ? buttonWrapper->Widget() : nullptr;
-    auto* listener      = buttonWidget ? buttonWidget->SemaphoreListener() : nullptr;
-    auto* button        = listener ? listener->TheButton() : nullptr;
-    if (button) {
+void PressAssignButton()
+{
+  for (auto* widget : unity::Instances<AssignShipsWidget>()) {
+    if (!widget || !CanvasController::Shows(widget) || !widget->isActiveAndEnabled())
+      continue;
+    auto* wrapper = widget->assignButton();
+    auto* button  = wrapper && wrapper->Widget() ? wrapper->Widget()->TheButton() : nullptr;
+    if (button)
       button->Press();
-    }
     return;
   }
 }
@@ -43,33 +128,101 @@ void PressAssignButton()
 
 void DoubleClickOnShipTileClicked(FleetPlayerData* ship)
 {
-  if (!Config::Get().double_click_to_assign_ship) return;
-  if (!ship) return;
-
-  const auto now             = std::chrono::steady_clock::now();
-  const bool is_double_click = ship == g_last_clicked_ship && (now - g_last_click_time) <= kDoubleClickWindow;
-
-  g_last_clicked_ship = ship;
-  g_last_click_time   = now;
+  if (!Config::Get().ui.double_click_to_assign_ship)
+    return;
+  if (!ship)
+    return;
 
-  if (!is_double_click) return;
+  const auto now          = std::chrono::steady_clock::now();
+  const bool double_click = ship == last_clicked_ship && now - last_click_time <= kDoubleClickWindow;
+  last_clicked_ship       = ship;
+  last_click_time         = now;
+  if (!double_click)
+    return;
 
-  g_last_clicked_ship = nullptr; // consume, so a triple/quadruple click doesn't re-trigger immediately
+  // Consumed, so a third click does not count as another double click.
+  last_clicked_ship = nullptr;
   PressAssignButton();
 }
 
-void AssignShipEnterKeyUpdate()
+void DockUpdate()
 {
-  if (!Config::Get().double_click_to_assign_ship) return;
-  if (!Key::Pressed(KeyCode::Return) && !Key::Pressed(KeyCode::KeypadEnter)) return;
-  if (Key::IsInputFocused()) return;
-
+  if (!Config::Get().ui.double_click_to_assign_ship)
+    return;
+  // Down, not Pressed: a held Enter must press Assign once, not every frame.
+  if (!unity::Key::Down(unity::KeyCode::Return) && !unity::Key::Down(unity::KeyCode::KeypadEnter))
+    return;
+  if (unity::Key::IsInputFocused())
+    return;
   PressAssignButton();
 }
 
-void InstallDoubleClickAssignShipHooks()
+namespace
 {
-  // The HandleOnClick detour is owned by the shared ship-tile click dispatcher
-  // (macOS only permits one hook per function).
-  ship_tile_click::TryInstallHook();
+void InstallPinnedShips()
+{ IL2CPP_HOOK(ShipManagementViewContext::Class::Method("Sort", 0), ShipManagementViewContext_Sort_Hook); }
+
+void InstallDoubleClickAssign()
+{ ship_tile_click::TryInstallHook(); }
+
+} // namespace
+
+const Feature kPinnedShips{"PinnedShips", &Config::Patches::pinnedshiphooks, InstallPinnedShips};
+const Feature kDoubleClickAssign{"DoubleClickAssign", &Config::Patches::doubleclickassignshiphooks,
+                                 InstallDoubleClickAssign};
+const Feature kAssignOnEnter{"AssignOnEnter", nullptr, nullptr, DockUpdate};
+
+namespace
+{
+void UpdateManageShipDockSelection()
+{
+  static uint64_t last_fleet_id = 0;
+  static auto     next_update   = std::chrono::steady_clock::time_point{};
+  const auto      now           = std::chrono::steady_clock::now();
+  if (now < next_update)
+    return;
+  next_update    = now + std::chrono::milliseconds(100);
+  auto* sections = Hub::Sections();
+  if (!Config::Get().ui.dock_syncmanagement || !sections
+      || sections->CurrentSection() != SectionID::ShipManagement_Details) {
+    last_fleet_id = 0;
+    return;
+  }
+  for (auto* controller : unity::Instances<ShipManagementViewController>()) {
+    if (!controller || !controller->isActiveAndEnabled())
+      continue;
+    auto* canvas = CanvasController::Of(controller);
+    if (!canvas || !canvas->Visible())
+      continue;
+    auto* context = controller->Context();
+    auto* fleet   = context ? context->CurrentFleet() : nullptr;
+    auto* manager = FleetsManager::Instance();
+    if (!fleet || !fleet->HasShip() || !manager || !manager->HasFleetService())
+      continue;
+    const auto index = fleet->Index();
+    if (index < 0)
+      continue;
+    // Exclude unassigned and synthetic fleets; management list order is not dock order.
+    auto* dock_fleet = manager->GetFleetPlayerData(index);
+    if (!dock_fleet || dock_fleet->Id() != fleet->Id())
+      continue;
+    if (last_fleet_id == fleet->Id())
+      return;
+    auto* bar = unity::Newest<FleetBarViewController>();
+    if (!bar)
+      return;
+    if (!bar->IsIndexSelected(index)) {
+      // Use the bar's selection flow to update both the highlight and fleet panel.
+      bar->RequestSelect(index);
+      if (!bar->IsIndexSelected(index))
+        return; // Retry next update if native selection was blocked.
+      spdlog::debug("[ManageShips] selected dock {} for fleet {}", index + 1, fleet->Id());
+    }
+    last_fleet_id = fleet->Id();
+    return;
+  }
+  last_fleet_id = 0;
 }
+
+} // namespace
+const Feature kDockSelection{"DockSelection", &Config::Patches::hotkeyhooks, nullptr, UpdateManageShipDockSelection};
diff --git a/mods/src/patches/parts/double_click_assign_ship.h b/mods/src/patches/parts/double_click_assign_ship.h
index 1ee8bff98..78eb81f51 100644
--- a/mods/src/patches/parts/double_click_assign_ship.h
+++ b/mods/src/patches/parts/double_click_assign_ship.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "prime/FleetPlayerData.h"
+#include "prime/fleet.h"
 
 void AssignShipEnterKeyUpdate();
 void DoubleClickOnShipTileClicked(FleetPlayerData* ship);
diff --git a/mods/src/patches/parts/fix_pan.cc b/mods/src/patches/parts/fix_pan.cc
deleted file mode 100644
index 2956718f1..000000000
--- a/mods/src/patches/parts/fix_pan.cc
+++ /dev/null
@@ -1,130 +0,0 @@
-#include "config.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <prime/Camera.h>
-#include <prime/Hub.h>
-#include <prime/NavigationPan.h>
-#include <prime/OrbitFrameProvider.h>
-#include <prime/ShortcutsManager.h>
-#include <prime/TKTouch.h>
-
-#include <patches/key.h>
-#include <patches/mapkey.h>
-
-#include <spud/detour.h>
-#include <cmath>
-
-TKTouch *TKTouch_populateWithPosition_Hook(auto original, TKTouch *_this, uintptr_t pos, TouchPhase phase)
-{
-  auto r = original(_this, pos, phase);
-  if (r->phase() == TouchPhase::Stationary) {
-    r->SetPhase(TouchPhase::Moved);
-  }
-  return r;
-}
-
-namespace
-{
-struct TutorialManager : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Tutorial", "TutorialManager">;
-
-  bool IsSceneInputAllowed()
-  { return Call<"IsSceneInputAllowed", bool>(); }
-};
-} // namespace
-
-// Retain the native tutorial and modal/text-input gates while replacing the
-// keyboard source through the existing LateUpdate hook, without new detours.
-bool KeyboardPanAllowed()
-{
-  auto* manager = Hub::Class::Get<"TutorialManager", TutorialManager*>();
-  return manager && manager->IsSceneInputAllowed() && ShortcutsManager::CanUseShortcuts() && !Key::IsInputFocused();
-}
-
-bool NavigationPan_LateUpdate_Hook(auto original, NavigationPan* _this)
-{
-  auto d = _this->lastDelta();
-  const auto& config = Config::Get();
-  const bool disable_target_camera_lock = config.disable_target_camera_lock;
-
-  if (disable_target_camera_lock && _this->trackingPOI()) {
-    _this->SetTrackingPOI(nullptr);
-  }
-  static auto GetMouseButton = il2cpp::ResolveICall<bool(int)>("UnityEngine.Input::GetMouseButton(System.Int32)");
-  static auto GetTouchCount  = il2cpp::ResolveICall<int()>("UnityEngine.Input::get_touchCount()");
-  // The native recognizer owns held-drag movement, including when the legacy
-  // Input API does not report the pointer. Never replay its delta as momentum.
-  const bool dragging = GetMouseButton(0) || GetTouchCount() > 0 || _this->panningStarted();
-  bool by_keys        = false;
-  bool native_handled = false;
-
-  if (!config.disable_move_keys && config.hotkeys_enabled && !Key::IsDirectionalInputClaimed()) {
-    if (config.use_scopely_hotkeys || !config.installHotkeyHooks) {
-      original(_this);
-      d              = _this->lastDelta();
-      native_handled = true;
-    } else if (!_this->BlockPan() && !_this->trackingPOI() && !dragging && KeyboardPanAllowed()) {
-      // Opposite bindings cancel; normalize diagonals like the native 2D composite.
-      float x = float(MapKey::IsPressed(GameFunction::MoveRight)) - float(MapKey::IsPressed(GameFunction::MoveLeft));
-      float y = float(MapKey::IsPressed(GameFunction::MoveUp)) - float(MapKey::IsPressed(GameFunction::MoveDown));
-      const float length = std::sqrt(x * x + y * y);
-      if (length > 0.0f) {
-        d.x = -x / length * _this->keyboardDeltaScaler();
-        d.y = -y / length * _this->keyboardDeltaScaler();
-        _this->SetLastDelta(d);
-        _this->MoveCamera(vec2{d.x * _this->deltaScaler(), d.y * _this->deltaScaler()}, true);
-        by_keys = true;
-      }
-    }
-  }
-
-  if (_this->BlockPan() || (_this->trackingPOI() && !disable_target_camera_lock)) {
-    d.x = 0.0f;
-    d.y = 0.0f;
-  } else if (!dragging && !by_keys) {
-    d.x               = d.x * Config::Get().system_pan_momentum_falloff;
-    d.y               = d.y * Config::Get().system_pan_momentum_falloff;
-    _this->SetLastDelta(d);
-    if (!native_handled) {
-      _this->MoveCamera(vec2{d.x, d.y}, true);
-    }
-  }
-  _this->SetLastDelta(d);
-  _this->SetFarMagRadiusRatioSystemExtended(_this->farMagRadiusRatioSystemNormal());
-  return true;
-}
-
-void OrbitFrameProvider_UpdateInputData_Hook(auto original, OrbitFrameProvider* _this, Camera* primary_camera)
-{
-  original(_this, primary_camera);
-
-  auto section_manager = Hub::get_SectionManager();
-  if (!Config::Get().hotkeys_enabled || Config::Get().use_scopely_hotkeys || Config::Get().disable_move_keys
-      || !section_manager || section_manager->CurrentSection() != SectionID::Starbase_Exterior || Key::IsInputFocused()) {
-    return;
-  }
-
-  static auto     GetDeltaTime            = il2cpp::ResolveICall<float()>("UnityEngine.Time::get_deltaTime()");
-  constexpr float keyboard_rotation_speed = 45.0f;
-  const auto      frame_delta             = keyboard_rotation_speed * GetDeltaTime();
-
-  if (MapKey::IsPressed(GameFunction::MoveLeft)) {
-    _this->SetRotationAngleDelta(_this->RotationAngleDelta() - frame_delta);
-  }
-  if (MapKey::IsPressed(GameFunction::MoveRight)) {
-    _this->SetRotationAngleDelta(_this->RotationAngleDelta() + frame_delta);
-  }
-}
-
-void InstallPanHooks()
-{
-  if (auto method = OrbitFrameProvider::Class::Method("UpdateInputData"))
-    SPUD_STATIC_DETOUR(method.Pointer(), OrbitFrameProvider_UpdateInputData_Hook);
-
-  if (auto method = TKTouch::Class::Method("populateWithPosition"))
-    SPUD_STATIC_DETOUR(method.Pointer(), TKTouch_populateWithPosition_Hook);
-
-  if (auto method = NavigationPan::Class::Method("LateUpdate"))
-    SPUD_STATIC_DETOUR(method.Pointer(), NavigationPan_LateUpdate_Hook);
-}
diff --git a/mods/src/patches/parts/fleet_labels.cc b/mods/src/patches/parts/fleet_labels.cc
new file mode 100644
index 000000000..5090e3488
--- /dev/null
+++ b/mods/src/patches/parts/fleet_labels.cc
@@ -0,0 +1,257 @@
+// zoom_label_player_* and zoom_label_non_player_*: how much detail fleet labels in system view show. The game picks
+// each label's level of detail from the camera's zoom; these settings override that per fleet kind. The camera's own
+// hooks in camera.cc report the zoom here.
+
+#include "config.h"
+#include "patches/patches.h"
+
+#include "prime/navigation.h"
+
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
+#include <spdlog/spdlog.h>
+
+#include <optional>
+#include <unordered_map>
+
+namespace
+{
+// Fleet label detail. The game picks each fleet label's LOD from the camera's zoom level; the zoom_label_*
+// settings override that per fleet kind: always expanded, always compact, or expanded below a zoom threshold.
+class FleetLabels
+{
+public:
+  bool installed = false;
+
+  static bool Enabled()
+  {
+    const auto& config = Config::Get();
+    return config.graphics.zoom_label_player.detail != FleetLabelDetail::kNative
+           || config.graphics.zoom_label_non_player.detail != FleetLabelDetail::kNative;
+  }
+
+  // The level `lod` should show instead of `native`, or nothing when its fleet is not tracked or labels are native.
+  std::optional<ZoomLevels> LevelFor(NavigationLOD* lod, ZoomLevels native) const
+  {
+    const auto* profile = Enabled() ? Profile(lod) : nullptr;
+    if (!profile)
+      return std::nullopt;
+    // Expanded keeps Near where the game would show it, and lifts everything else to Middle.
+    const auto expanded = native == ZoomLevels::Near ? ZoomLevels::Near : ZoomLevels::Middle;
+    switch (profile->detail) {
+      case FleetLabelDetail::kExpanded:
+        return expanded;
+      case FleetLabelDetail::kCompact:
+        return ZoomLevels::Far;
+      case FleetLabelDetail::kThreshold:
+        if (!zoom_known_)
+          return native;
+        return ExpandedAt(profile->zoom_threshold) ? expanded : ZoomLevels::Far;
+      default:
+        return native;
+    }
+  }
+
+  void Track(NavigationFleetWidget* widget)
+  {
+    // Fresh pooled widgets are enabled before BindDataContext assigns their context; forcing an LOD before then
+    // fires OnLODChanged callbacks that dereference the unbound fleet data.
+    auto* lod = widget && widget->Context() ? widget->lod() : nullptr;
+    if (!lod)
+      return;
+    widgets_.insert_or_assign(lod, widget);
+    if (zoom_known_ && Enabled())
+      lod->UpdateLOD(zoom_level_);
+  }
+
+  void Untrack(NavigationFleetWidget* widget)
+  {
+    auto* lod = widget ? widget->lod() : nullptr;
+    if (!lod)
+      return;
+    widgets_.erase(lod);
+    // Give a reused widget back to the game at the game's own level.
+    if (widget->Context() && zoom_known_ && Enabled()) {
+      lod->SetTargetLevel(zoom_level_);
+      lod->UpdateLOD(zoom_level_);
+      lod->SetTargetLevel(zoom_level_);
+    }
+  }
+
+  // The camera `zoom` is about to show `depth`. Labels only apply in a solar system, and a new camera starts over.
+  void OnDepth(NavigationZoom* zoom, NodeDepth depth)
+  {
+    if (!installed)
+      return;
+    if (depth == NodeDepth::SolarSystem) {
+      Follow(zoom);
+    } else if (camera_ == zoom) {
+      Forget();
+    }
+  }
+
+  // After the camera's own update: picks up the zoom level and re-applies labels when they change.
+  void OnZoomed(NavigationZoom* zoom)
+  {
+    if (!installed || zoom->depth() != NodeDepth::SolarSystem)
+      return;
+    Follow(zoom);
+    const bool was_known = zoom_known_;
+    zoom_level_          = zoom->zoomLevel();
+    zoom_known_          = true;
+    if (UsesThreshold()) {
+      normalized_zoom_ = zoom->NormalizedZoom();
+      UpdateThreshold();
+    } else if (!was_known) {
+      ApplyAll();
+    }
+  }
+
+private:
+  const FleetLabelProfile* Profile(NavigationLOD* lod) const
+  {
+    const auto it     = widgets_.find(lod);
+    auto*      widget = it == widgets_.end() ? nullptr : it->second;
+    auto*      fleet  = widget ? widget->Context() : nullptr;
+    if (!fleet)
+      return nullptr;
+    // A missing FleetType property reads as Nonexistent, which counts as non-player.
+    const auto& config = Config::Get();
+    return fleet->FleetType() == DeployedFleetType::Player ? &config.graphics.zoom_label_player
+                                                           : &config.graphics.zoom_label_non_player;
+  }
+
+  static bool UsesThreshold()
+  {
+    const auto& config = Config::Get();
+    return config.graphics.zoom_label_player.detail == FleetLabelDetail::kThreshold
+           || config.graphics.zoom_label_non_player.detail == FleetLabelDetail::kThreshold;
+  }
+
+  // Labels expand when zoomed in at least as far as the threshold. 0 never expands, 1 always does.
+  bool ExpandedAt(float threshold) const
+  { return threshold > 0.0f && (threshold >= 1.0f || normalized_zoom_ <= threshold); }
+
+  void Follow(NavigationZoom* zoom)
+  {
+    if (camera_ != zoom) {
+      Forget();
+      camera_ = zoom;
+    }
+  }
+
+  void Forget()
+  {
+    camera_          = nullptr;
+    zoom_known_      = false;
+    zoom_level_      = ZoomLevels::None;
+    normalized_zoom_ = 0.0f;
+    threshold_known_ = false;
+  }
+
+  // UpdateLOD goes through the hook, which picks each label's level.
+  void ApplyAll()
+  {
+    if (!Enabled())
+      return;
+    for (const auto& [lod, widget] : widgets_)
+      if (widget->Context())
+        lod->UpdateLOD(zoom_level_);
+  }
+
+  // Re-applies labels only when a threshold profile crosses its threshold, not on every zoom step.
+  void UpdateThreshold()
+  {
+    const auto& config     = Config::Get();
+    const bool  player     = config.graphics.zoom_label_player.detail == FleetLabelDetail::kThreshold
+                             && ExpandedAt(config.graphics.zoom_label_player.zoom_threshold);
+    const bool  non_player = config.graphics.zoom_label_non_player.detail == FleetLabelDetail::kThreshold
+                             && ExpandedAt(config.graphics.zoom_label_non_player.zoom_threshold);
+    if (threshold_known_ && player == player_expanded_ && non_player == non_player_expanded_)
+      return;
+    threshold_known_     = true;
+    player_expanded_     = player;
+    non_player_expanded_ = non_player;
+    ApplyAll();
+#ifdef _MODDBG
+    spdlog::info("Fleet label detail threshold state updated at normalized zoom {:.4f}", normalized_zoom_);
+#endif
+  }
+
+  std::unordered_map<NavigationLOD*, NavigationFleetWidget*> widgets_;
+  // The system camera the zoom state below belongs to.
+  NavigationZoom* camera_              = nullptr;
+  bool            zoom_known_          = false;
+  ZoomLevels      zoom_level_          = ZoomLevels::None;
+  float           normalized_zoom_     = 0.0f;
+  bool            threshold_known_     = false;
+  bool            player_expanded_     = false;
+  bool            non_player_expanded_ = false;
+} labels;
+
+void NavigationLOD_UpdateLOD_Hook(auto original, NavigationLOD* _this, ZoomLevels level)
+{
+  const auto effective = labels.LevelFor(_this, level);
+  if (!effective)
+    return original(_this, level);
+  // The target level is set on both sides of the update so the game's own bookkeeping agrees with ours.
+  _this->SetTargetLevel(*effective);
+  original(_this, *effective);
+  _this->SetTargetLevel(*effective);
+}
+
+void NavigationFleetWidget_OnEnable_Hook(auto original, NavigationFleetWidget* _this)
+{
+  original(_this);
+  labels.Track(_this);
+}
+
+void NavigationFleetWidget_OnDidBindContext_Hook(auto original, NavigationFleetWidget* _this)
+{
+  original(_this);
+  labels.Track(_this);
+}
+
+void NavigationFleetWidget_OnDisable_Hook(auto original, NavigationFleetWidget* _this)
+{
+  labels.Untrack(_this);
+  original(_this);
+}
+
+void NavigationFleetWidget_OnAboutToReleaseContext_Hook(auto original, NavigationFleetWidget* _this)
+{
+  labels.Untrack(_this);
+  original(_this);
+}
+
+void InstallFleetLabels()
+{
+  // Installed as a set, whether or not zoom_label_* is set, so labels can be switched at runtime. Missing fields
+  // and properties (_lod, Context, FleetType) read as null or zero, which the hooks treat as native labels, so
+  // only the methods gate installation. The zoom reports come from camera.cc's NavigationZoom.Update hook.
+  auto update     = NavigationZoom::Class::Method("Update");
+  auto update_lod = NavigationLOD::Class::Method("UpdateLOD");
+  auto on_enable  = NavigationFleetWidget::Class::Method("OnEnable");
+  auto on_disable = NavigationFleetWidget::Class::Method("OnDisable");
+  auto on_bind    = NavigationFleetWidget::Class::Method("OnDidBindContext");
+  auto on_release = NavigationFleetWidget::Class::Method("OnAboutToReleaseContext");
+  if (!update || !update_lod || !on_enable || !on_disable || !on_bind || !on_release) {
+    spdlog::error("Fleet label detail hooks were not installed; using native fleet labels");
+    return;
+  }
+  labels.installed = true;
+  IL2CPP_HOOK(update_lod, NavigationLOD_UpdateLOD_Hook);
+  IL2CPP_HOOK(on_enable, NavigationFleetWidget_OnEnable_Hook);
+  IL2CPP_HOOK(on_disable, NavigationFleetWidget_OnDisable_Hook);
+  IL2CPP_HOOK(on_bind, NavigationFleetWidget_OnDidBindContext_Hook);
+  IL2CPP_HOOK(on_release, NavigationFleetWidget_OnAboutToReleaseContext_Hook);
+}
+} // namespace
+
+void FleetLabelsFollowDepth(NavigationZoom* zoom, NodeDepth depth)
+{ labels.OnDepth(zoom, depth); }
+
+void FleetLabelsAfterZoom(NavigationZoom* zoom)
+{ labels.OnZoomed(zoom); }
+
+const Feature kFleetLabels{"FleetLabels", &Config::Patches::zoomhooks, InstallFleetLabels};
diff --git a/mods/src/patches/parts/focus_search.cc b/mods/src/patches/parts/focus_search.cc
deleted file mode 100644
index 076ca5a4d..000000000
--- a/mods/src/patches/parts/focus_search.cc
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "focus_search.h"
-#include "patches/object_tracker.h"
-
-#include "config.h"
-
-#include "prime/AssignShipsWidget.h"
-#include "prime/CanvasController.h"
-#include "prime/ChatMessageListLocalViewController.h"
-#include "prime/InventoryListViewController.h"
-#include "prime/OfficerAssignmentViewController.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <spdlog/spdlog.h>
-
-bool FocusSearchBox()
-{
-  if (!Config::Get().focus_search) {
-    return false;
-  }
-
-  // Guard chat input so we don't steal focus from the chat text box
-  if (auto chat = ObjectFinder<ChatMessageListLocalViewController>::Get(); chat && chat->inputFieldSelected()) {
-#ifdef _MODDBG
-    spdlog::info("[FocusSearch] blocked: chat input is selected");
-#endif
-    return false;
-  }
-
-  // InventoryListViewController covers OfficerRosterViewController and other inventory subclasses
-  auto inventoryControllers = ObjectFinder<InventoryListViewController>::GetAll();
-  for (auto controller : inventoryControllers) {
-    if (!controller || !controller->inputField()) {
-      continue;
-    }
-
-    auto canvas  = controller->canvasController();
-    bool visible = canvas && canvas->Visible();
-    bool active  = controller->isActiveAndEnabled() && controller->inputField()->isActiveAndEnabled();
-    spdlog::debug("[FocusSearch] inventory controller={} section={} canvas={} visible={} active={}", (void*)controller,
-                 (int32_t)controller->targetSection(), (void*)canvas, visible, active);
-
-    if (visible && active) {
-#ifdef _MODDBG
-      spdlog::info("[FocusSearch] focusing visible inventory search");
-#endif
-      controller->inputField()->Focus();
-      return true;
-    }
-  }
-
-  // OfficerAssignmentViewController (separate from inventory list)
-  auto officerControllers = ObjectFinder<OfficerAssignmentViewController>::GetAll();
-  for (auto controller : officerControllers) {
-    if (!controller || !controller->inputField()) {
-      continue;
-    }
-
-    auto canvas  = controller->canvasController();
-    bool visible = canvas && canvas->Visible();
-    bool active  = controller->isActiveAndEnabled() && controller->inputField()->isActiveAndEnabled();
-    spdlog::debug("[FocusSearch] officer assignment controller={} canvas={} visible={} active={}", (void*)controller,
-                 (void*)canvas, visible, active);
-
-    if (visible && active) {
-#ifdef _MODDBG
-      spdlog::info("[FocusSearch] focusing visible officer assignment search");
-#endif
-      controller->inputField()->Focus();
-      return true;
-    }
-  }
-
-  // AssignShipsWidget (ship selection / assignment)
-  auto assignShipWidgets = ObjectFinder<AssignShipsWidget>::GetAll();
-  for (auto widget : assignShipWidgets) {
-    if (!widget || !widget->inputField()) {
-      continue;
-    }
-
-    auto canvas  = GetCanvasControllerFromComponent(widget);
-    bool visible = canvas && canvas->Visible();
-    bool active  = widget->isActiveAndEnabled() && widget->inputField()->isActiveAndEnabled();
-    spdlog::debug("[FocusSearch] assign ships widget={} canvas={} visible={} active={}", (void*)widget, (void*)canvas,
-                 visible, active);
-
-    if (visible && active) {
-#ifdef _MODDBG
-      spdlog::info("[FocusSearch] focusing visible assign ships search");
-#endif
-      widget->inputField()->Focus();
-      return true;
-    }
-  }
-
-  return false;
-}
diff --git a/mods/src/patches/parts/focus_search.h b/mods/src/patches/parts/focus_search.h
deleted file mode 100644
index a1744e32f..000000000
--- a/mods/src/patches/parts/focus_search.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#pragma once
-
-bool FocusSearchBox();
diff --git a/mods/src/patches/parts/forbidden_tech_confirmation.cc b/mods/src/patches/parts/forbidden_tech_confirmation.cc
index 2c67c5533..98b5e60ab 100644
--- a/mods/src/patches/parts/forbidden_tech_confirmation.cc
+++ b/mods/src/patches/parts/forbidden_tech_confirmation.cc
@@ -1,66 +1,47 @@
+// auto_confirm_ft_upgrade: answers the forbidden tech upgrade confirmation with Confirm instead of showing it.
+
 #include "config.h"
+#include "patches/patches.h"
+
+#include "prime/ui.h"
 
+#include <il2cpp/hook.h>
 #include <il2cpp/il2cpp.h>
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
 
-#include <cstring>
+#include <string>
 
 namespace
 {
-constexpr int32_t ConfirmButtonResult = 1;
-constexpr int32_t YesButtonResult     = 3;
-
-using MessageBox = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "MessageBox">;
-
-struct MessageBoxContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "MessageBoxContext">;
-
-  // Action<MessageBox.ButtonResult>
-  Il2CppDelegate* OnSelection()
-  { return Field<"OnSelection", Il2CppDelegate*>(); }
-};
-
+// The closure ForbiddenTechManager.RequestAction passes as the confirmation callback.
 bool IsForbiddenTechConfirmation(const Il2CppDelegate* callback)
 {
-  if (callback == nullptr || callback->target == nullptr || callback->method == nullptr) {
+  if (!callback || !callback->target || !callback->method || callback->method->parameters_count != 1)
     return false;
-  }
-
-  const auto* target_class = callback->target->klass;
-  const auto* owner_class  = target_class == nullptr ? nullptr : target_class->declaringType;
-
-  return owner_class != nullptr && strcmp(owner_class->name, "ForbiddenTechManager") == 0 &&
-         strcmp(callback->method->name, "<RequestAction>b__0") == 0;
+  // "Digit.Prime.ForbiddenTech.ForbiddenTechManager/<>c__DisplayClass12_0.<RequestAction>b__0", or similar.
+  const auto name  = il2cpp::Method(callback->method).Name();
+  const auto owner = name.find("ForbiddenTechManager/");
+  return owner != std::string::npos && (owner == 0 || name[owner - 1] == '.') && name.ends_with(".<RequestAction>b__0");
 }
 
 bool IsAllianceContributionMaxLevelWarning(const Il2CppDelegate* callback)
 {
-  if (callback == nullptr || callback->target == nullptr || callback->method == nullptr) {
+  if (!callback || !callback->target || !callback->method || callback->method->parameters_count != 1)
     return false;
-  }
-
-  const auto* target_class = callback->target->klass;
-  const auto* owner_class  = target_class == nullptr ? nullptr : target_class->declaringType;
-
-  return owner_class != nullptr && strcmp(owner_class->name, "AllianceContributionViewController") == 0
-         && strcmp(callback->method->name, "<RequestAction>b__0") == 0;
+  const auto name  = il2cpp::Method(callback->method).Name();
+  const auto owner = name.find("AllianceContributionViewController/");
+  return owner != std::string::npos && (owner == 0 || name[owner - 1] == '.') && name.ends_with(".<RequestAction>b__0");
 }
 
 bool ConfirmForbiddenTechUpgrade(Il2CppDelegate* callback)
 {
-  if (!Config::Get().auto_confirm_ft_upgrade || !IsForbiddenTechConfirmation(callback)) {
+  if (!Config::Get().ui.auto_confirm_ft_upgrade || !IsForbiddenTechConfirmation(callback))
     return false;
-  }
 
-  // The closure was identified above, so call its method directly. If it throws, show the dialog
-  // instead so the upgrade is never lost silently.
-  using Closure = void (*)(Il2CppObject*, int32_t, const MethodInfo*);
-  if (callback->method->parameters_count != 1)
-    return false;
+  // The closure was identified above, so call its method directly. If it throws, show the dialog instead so the
+  // upgrade is never lost silently.
   try {
-    reinterpret_cast<Closure>(callback->method->methodPointer)(callback->target, ConfirmButtonResult,
-                                                               callback->method);
+    il2cpp::InvokeBound(callback, MessageBoxResult::Confirm);
   } catch (...) {
     spdlog::warn("ForbiddenTechConfirmation: confirmation callback threw; showing the dialog");
     return false;
@@ -70,17 +51,14 @@ bool ConfirmForbiddenTechUpgrade(Il2CppDelegate* callback)
 
 bool ConfirmAllianceContribution(Il2CppDelegate* callback)
 {
-  if (!Config::Get().auto_confirm_alliance_contribution || !IsAllianceContributionMaxLevelWarning(callback)) {
+  if (!Config::Get().ui.auto_confirm_alliance_contribution || !IsAllianceContributionMaxLevelWarning(callback)) {
     return false;
   }
 
-  int32_t          result    = YesButtonResult;
-  void*            args[]    = {&result};
-  Il2CppException* exception = nullptr;
-  il2cpp_runtime_invoke(callback->method, callback->target, args, &exception);
-
-  if (exception != nullptr) {
-    spdlog::warn("AllianceContributionConfirmation: failed to invoke the confirmation callback");
+  try {
+    il2cpp::InvokeBound(callback, MessageBoxResult::Yes);
+  } catch (...) {
+    spdlog::warn("AllianceContributionConfirmation: confirmation callback threw; showing the dialog");
     return false;
   }
 
@@ -101,12 +79,13 @@ void MessageBox_ShowWithCallback_Hook(auto original, MessageBoxContext* context,
     original(context, callback);
   }
 }
-} // namespace
 
-void InstallForbiddenTechConfirmationHooks()
+void InstallForbiddenTechConfirm()
 {
-  if (auto m = MessageBox::Method("Show", 1))
-    SPUD_STATIC_DETOUR(m.Pointer(), MessageBox_Show_Hook);
-  if (auto m = MessageBox::Method("Show", 2))
-    SPUD_STATIC_DETOUR(m.Pointer(), MessageBox_ShowWithCallback_Hook);
+  IL2CPP_HOOK(GameMessageBox::Method("Show", 1), MessageBox_Show_Hook);
+  IL2CPP_HOOK(GameMessageBox::Method("Show", 2), MessageBox_ShowWithCallback_Hook);
 }
+} // namespace
+
+const Feature kForbiddenTechConfirm{"ForbiddenTechConfirm", &Config::Patches::forbiddentechconfirmhooks,
+                                    InstallForbiddenTechConfirm};
diff --git a/mods/src/patches/parts/forbidden_tech_ship_name.cc b/mods/src/patches/parts/forbidden_tech_ship_name.cc
index eff78d869..067b7b697 100644
--- a/mods/src/patches/parts/forbidden_tech_ship_name.cc
+++ b/mods/src/patches/parts/forbidden_tech_ship_name.cc
@@ -1,18 +1,18 @@
+// forbidden_tech_ship_name: shows the ship a forbidden tech is equipped on below the header of the large selected-item
+// panel, including ships without a dock. Inventory tiles keep their native dock badges.
+
 #include "config.h"
-#include "ship_name_match.h"
+#include "patches/patches.h"
 
-#include <prime/Color.h>
-#include <prime/Component.h>
-#include <prime/HullSpec.h>
-#include <prime/MonoSingleton.h>
-#include <prime/RectTransform.h>
-#include <prime/TextLocalizer.h>
-#include <prime/Vector2.h>
-#include <prime/Widget.h>
+#include "prime/fleet.h"
+#include "prime/inventory.h"
+#include "prime/ui.h"
 
+#include <il2cpp/hook.h>
 #include <il2cpp/il2cpp.h>
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
+#include <unity/core.h>
+#include <unity/ui.h>
 
 #include <algorithm>
 #include <iterator>
@@ -24,123 +24,16 @@ namespace
 {
 constexpr float RowHeight = 30.0f;
 
-using UnityObject = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Object">;
-
-struct ForbiddenTech : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "ForbiddenTech">;
-
-  int64_t Id()
-  { return Get<"Id", int64_t>(); }
-};
-
-struct ForbiddenTechInventoryItem : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "InventoryItem">;
-
-  ForbiddenTech* forbiddenTech()
-  { return Get<"ForbiddenTech", ForbiddenTech*>(); }
-};
-
-struct ForbiddenTechSlotParams : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "ForbiddenTechSlotParams">;
-
-  int64_t OwnerId()
-  { return Get<"OwnerId", int64_t>(); }
-};
-
-struct ForbiddenTechEntitySlot : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "EntitySlot">;
-
-  ForbiddenTechSlotParams* forbiddenTechSlotParams()
-  { return Get<"ForbiddenTechSlotParams", ForbiddenTechSlotParams*>(); }
-};
-
-// GetShip returns an IShipModel, read on its runtime class.
-struct ForbiddenTechFleetService : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "FleetService">;
-
-  il2cpp::Object* GetShip(int64_t ship_id)
-  { return Call<"GetShip", il2cpp::Object*>(ship_id); }
-};
-
-struct ForbiddenTechManager : MonoSingleton<ForbiddenTechManager> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ForbiddenTechs", "ForbiddenTechManager">;
-
-  bool TryGetEntitySlotFromForbiddenTech(int64_t tech_id, ForbiddenTechEntitySlot*& slot)
-  { return Call<"TryGetEntitySlotFromForbiddenTech", bool>(tech_id, std::ref(slot)); }
-
-  // _fleetServiceCache is a CachedService<FleetService> struct whose Service getter resolves the
-  // service lazily. The getter runs on a copy, so the manager's own cache is left as it was; the
-  // runtime takes the struct receiver unboxed.
-  ForbiddenTechFleetService* fleetService()
-  {
-    struct CachedService {
-      ForbiddenTechFleetService* service;
-    };
-    auto cache = Field<"_fleetServiceCache", CachedService>();
-    if (cache.service)
-      return cache.service;
-    static FieldInfo* const field =
-        Class::Raw() ? il2cpp_class_get_field_from_name(Class::Raw(), "_fleetServiceCache") : nullptr;
-    static const MethodInfo* const getter =
-        field ? il2cpp_class_get_method_from_name(il2cpp_class_from_type(il2cpp_field_get_type(field)), "get_Service",
-                                                  0)
-              : nullptr;
-    if (!getter)
-      return nullptr;
-    return reinterpret_cast<ForbiddenTechFleetService*>(il2cpp::detail::InvokeBoxed(getter, &cache, nullptr));
-  }
-};
-
-struct ForbiddenTechInventoryItemWidget : Widget<ForbiddenTechInventoryItem> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ForbiddenTechs", "ForbiddenTechInventoryItemWidget">;
-
-  // ForbiddenTechInventoryItemWidget.WidgetType; 1 is the large selected-item panel.
-  int32_t widgetType()
-  { return Field<"_widgetType", int32_t>(); }
-  // SmartScroller
-  Component* buffListScroller()
-  { return Field<"_buffListScroller", Component*>(); }
-  TextLocalizer* name()
-  { return Field<"_name", TextLocalizer*>(); }
-};
-
-struct TMP_Text : il2cpp::Object {
-  using Class = il2cpp::Class<"Unity.TextMeshPro", "TMPro", "TMP_Text">;
-
-  // TextAlignmentOptions
-  void SetAlignment(int32_t value)
-  { Set<"alignment">(value); }
-  void SetRaycastTarget(bool value)
-  { Set<"raycastTarget">(value); }
-  void SetRichText(bool value)
-  { Set<"richText">(value); }
-  void SetEnableWordWrapping(bool value)
-  { Set<"enableWordWrapping">(value); }
-  // TextOverflowModes
-  void SetOverflowMode(int32_t value)
-  { Set<"overflowMode">(value); }
-  void SetEnableAutoSizing(bool value)
-  { Set<"enableAutoSizing">(value); }
-  void SetFontSize(float value)
-  { Set<"fontSize">(value); }
-  void SetColor(color value)
-  { Set<"color">(value); }
-};
-
-// Unity's `bool(UnityEngine.Object)`: false for null and for destroyed native objects.
-bool Alive(il2cpp::Object* object)
-{ return object && UnityObject::Call<"op_Implicit", bool>(object); }
-
-RectTransform* RectOf(il2cpp::Object* component)
+unity::RectTransform* RectOf(il2cpp::Object* component)
 {
-  auto* as_component = component ? component->As<Component>() : nullptr;
+  auto* as_component = component ? component->As<unity::Component>() : nullptr;
   auto* transform    = as_component ? as_component->transform() : nullptr;
-  return transform ? transform->As<RectTransform>() : nullptr;
+  return transform ? transform->As<unity::RectTransform>() : nullptr;
 }
 
 void SetActive(il2cpp::Object* component, bool active)
 {
-  auto* as_component = component->As<Component>();
+  auto* as_component = component->As<unity::Component>();
   auto* object       = as_component ? as_component->gameObject() : nullptr;
   if (!object)
     throw std::runtime_error("Forbidden Tech label object unavailable");
@@ -160,7 +53,7 @@ std::string EquippedShipName(ForbiddenTechInventoryItemWidget* widget)
 
   // The fleet-index API returns -1 for a ship in the hangar. Resolve the slot's
   // OwnerId instead; it identifies the actual ship regardless of dock assignment.
-  ForbiddenTechEntitySlot* slot = nullptr;
+  EntitySlot* slot = nullptr;
   if (!manager->TryGetEntitySlotFromForbiddenTech(id, slot) || !slot)
     return {};
   auto* params = slot->forbiddenTechSlotParams();
@@ -172,31 +65,31 @@ std::string EquippedShipName(ForbiddenTechInventoryItemWidget* widget)
   if (!service)
     return {};
   auto* ship = service->GetShip(owner);
-  auto* hull = ship ? ship->Get<"Hull", HullSpec*>() : nullptr;
+  auto* hull = ship ? ship->Hull() : nullptr;
   if (!hull)
     return {};
   // Hull IDs and localisation IDs differ on many ships. Mirror FleetPlayerData.GetLocaId.
   auto*      refs    = hull->idRefs();
   const auto loca_id = refs ? refs->locaId() : hull->Id();
-  return ShipNameMatch::LocalizedShipName(loca_id);
+  return LocalizedShipName(loca_id);
 }
 
 struct Row {
   il2cpp::GcHandle scroller;
   il2cpp::GcHandle label;
-  Vector2          original_top{};
+  unity::Vector2   original_top{};
   bool             visible = false;
 
-  RectTransform* Scroller() const
-  { return scroller.Get<RectTransform>(); }
+  unity::RectTransform* Scroller() const
+  { return scroller.Get<unity::RectTransform>(); }
   TextLocalizer* Label() const
   { return label.Get<TextLocalizer>(); }
 
   void Hide()
   {
-    if (Alive(Label()))
+    if (unity::Alive(Label()))
       SetActive(Label(), false);
-    if (visible && Alive(Scroller()))
+    if (visible && unity::Alive(Scroller()))
       Scroller()->SetOffsetMax(original_top);
     visible = false;
   }
@@ -206,7 +99,7 @@ std::vector<Row> rows;
 void HideWidgetRow(ForbiddenTechInventoryItemWidget* widget)
 {
   auto* scroller = widget->buffListScroller();
-  if (!Alive(scroller))
+  if (!unity::Alive(scroller))
     return;
   auto* rect = RectOf(scroller);
   for (auto& row : rows) {
@@ -215,31 +108,20 @@ void HideWidgetRow(ForbiddenTechInventoryItemWidget* widget)
   }
 }
 
-TextLocalizer* CloneLabel(TextLocalizer* source, Transform* parent)
-{
-  // This client exposes the two-argument overload only as Instantiate<T>.
-  // Use the non-generic three-argument overload so no generic inflation is required.
-  auto* clone =
-      UnityObject::Call<"Instantiate", il2cpp::Object*(il2cpp::Object*, Transform*, bool)>(source, parent, false);
-  if (!Alive(clone))
-    throw std::runtime_error("Forbidden Tech ship label could not be created");
-  return static_cast<TextLocalizer*>(clone);
-}
-
 void UpdateRow(ForbiddenTechInventoryItemWidget* widget)
 {
   // Only the large selected-item panel: inventory tiles retain their native dock badges.
-  if (widget->widgetType() != 1)
+  if (widget->widgetType() != ForbiddenTechInventoryItemWidget::Type::LargeShowcase)
     return;
 
   auto* scroller = widget->buffListScroller();
-  if (!Alive(scroller))
+  if (!unity::Alive(scroller))
     return;
   auto* rect = RectOf(scroller);
   if (!rect)
     throw std::runtime_error("Forbidden Tech buff layout unavailable");
 
-  std::erase_if(rows, [](const Row& row) { return !Alive(row.Scroller()); });
+  std::erase_if(rows, [](const Row& row) { return !unity::Alive(row.Scroller()); });
   auto found = std::find_if(rows.begin(), rows.end(), [rect](const Row& row) { return row.Scroller() == rect; });
   if (found == rows.end()) {
     Row row;
@@ -255,7 +137,7 @@ void UpdateRow(ForbiddenTechInventoryItemWidget* widget)
   row.Hide();
   // Native refresh may have resized the panel since the previous selection.
   row.original_top = rect->offsetMax();
-  if (!Config::Get().forbidden_tech_ship_name)
+  if (!Config::Get().ui.forbidden_tech_ship_name)
     return;
   const auto name = EquippedShipName(widget);
   if (name.empty())
@@ -263,11 +145,13 @@ void UpdateRow(ForbiddenTechInventoryItemWidget* widget)
 
   try {
     auto* label = row.Label();
-    if (!Alive(label)) {
+    if (!unity::Alive(label)) {
       auto* source = widget->name();
-      if (!Alive(source))
+      if (!unity::Alive(source))
         return;
-      label = CloneLabel(source, rect->parent());
+      label = unity::Instantiate(source, rect->parent());
+      if (!unity::Alive(label))
+        throw std::runtime_error("Forbidden Tech ship label could not be created");
       SetActive(label, false);
       row.label = il2cpp::GcHandle::Weak(label);
       if (!row.label)
@@ -289,18 +173,18 @@ void UpdateRow(ForbiddenTechInventoryItemWidget* widget)
 
     // Target resolves the graphic lazily, even when the source label was inactive at clone time.
     auto* target = label->Target();
-    auto* text   = target ? target->As<TMP_Text>() : nullptr;
+    auto* text   = target ? target->As<unity::TMP_Text>() : nullptr;
     if (!text)
       throw std::runtime_error("Forbidden Tech ship label text unavailable");
-    text->SetAlignment(513); // TMP TextAlignmentOptions.Left (left, vertically centred).
+    text->SetAlignment(unity::TMP_Text::Alignment::Left); // Left, vertically centred.
     text->SetRaycastTarget(false);
     text->SetRichText(false); // Ship names are plain text, never markup.
     text->SetEnableWordWrapping(false);
-    text->SetOverflowMode(1); // TMP TextOverflowModes.Ellipsis; long names stay within this row.
+    text->SetOverflowMode(unity::TMP_Text::Overflow::Ellipsis); // Long names stay within this row.
     text->SetEnableAutoSizing(false);
     text->SetFontSize(20.0f);
     text->SetColor({1.0f, 1.0f, 1.0f, 1.0f});
-    label->OverrideLocalizedText(il2cpp_string_new(("Equipped on: " + name).c_str()));
+    label->OverrideLocalizedText(il2cpp::NewString("Equipped on: " + name));
     // Keep the panel's outer size, reserving one row from the scrollable buff area.
     rect->SetOffsetMax({max.x, max.y - RowHeight});
     row.visible = true;
@@ -342,9 +226,8 @@ void ForbiddenTechInventoryItemWidget_ClearWidgetData_Hook(auto original, Forbid
   }
   original(_this);
 }
-} // namespace
 
-void InstallForbiddenTechShipNameHooks()
+void InstallForbiddenTechShipName()
 {
   auto method = ForbiddenTechInventoryItemWidget::Class::Method("SetWidgetData", 0);
   auto clear  = ForbiddenTechInventoryItemWidget::Class::Method("ClearWidgetData", 0);
@@ -358,11 +241,14 @@ void InstallForbiddenTechShipNameHooks()
     return;
   }
   // Install cleanup first; failure leaves the native panel entirely untouched.
-  if (!SPUD_STATIC_DETOUR(clear.Pointer(), ForbiddenTechInventoryItemWidget_ClearWidgetData_Hook)) {
+  if (!IL2CPP_HOOK(clear, ForbiddenTechInventoryItemWidget_ClearWidgetData_Hook)) {
     spdlog::warn("[ForbiddenTechShipName] widget cleanup hook unavailable; native display retained");
     return;
   }
-  const bool installed =
-      SPUD_STATIC_DETOUR(method.Pointer(), ForbiddenTechInventoryItemWidget_SetWidgetData_Hook) != nullptr;
+  const bool installed = IL2CPP_HOOK(method, ForbiddenTechInventoryItemWidget_SetWidgetData_Hook) != nullptr;
   spdlog::info("[ForbiddenTechShipName] widget refresh hook {}", installed ? "installed" : "unavailable");
 }
+} // namespace
+
+const Feature kForbiddenTechShipName{"ForbiddenTechShipName", &Config::Patches::forbiddentechshipnamehooks,
+                                     InstallForbiddenTechShipName};
diff --git a/mods/src/patches/parts/free_resize.cc b/mods/src/patches/parts/free_resize.cc
deleted file mode 100644
index 81706ab0b..000000000
--- a/mods/src/patches/parts/free_resize.cc
+++ /dev/null
@@ -1,162 +0,0 @@
-#if _WIN32
-#include <Windows.h>
-
-#include "config.h"
-#include "file.h"
-
-#include <spud/detour.h>
-
-#include "prime/AspectRatioConstraintHandler.h"
-#include "windowtitle.h"
-
-static bool            WndProcInstalled  = false;
-static LONG_PTR        oWndProc          = NULL;
-static WINDOWPLACEMENT g_wpPrev          = {sizeof(g_wpPrev)};
-LONG                   oldWindowStandard = 0;
-LONG                   oldWindowExtended = 0;
-HWND                   unityWindow       = nullptr;
-
-void ToggleFullscreen(HWND hWnd)
-{
-  // Get window styles
-  auto styleCurrentWindowStandard = GetWindowLong(hWnd, GWL_STYLE);
-  auto styleCurrentWindowExtended = GetWindowLong(hWnd, GWL_EXSTYLE);
-
-  if (styleCurrentWindowStandard & WS_OVERLAPPEDWINDOW) {
-
-    oldWindowStandard = styleCurrentWindowStandard;
-    oldWindowExtended = styleCurrentWindowExtended;
-
-    // Compute new styles (XOR of the inverse of all the bits to filter)
-    auto styleNewWindowStandard = styleCurrentWindowStandard
-                                  & ~(WS_CAPTION | WS_THICKFRAME | WS_OVERLAPPEDWINDOW | WS_SYSMENU | WS_MAXIMIZEBOX
-                                      | WS_MINIMIZEBOX // same as Group
-                                  );
-
-    auto styleNewWindowExtended = styleCurrentWindowExtended
-                                  & ~(WS_EX_DLGMODALFRAME | WS_EX_COMPOSITED | WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE
-                                      | WS_EX_LAYERED | WS_EX_STATICEDGE | WS_EX_TOOLWINDOW | WS_EX_APPWINDOW);
-
-    SetWindowLong(hWnd, GWL_STYLE, styleNewWindowStandard);
-    SetWindowLong(hWnd, GWL_EXSTYLE, styleNewWindowExtended);
-
-    MONITORINFO mi = {sizeof(mi)};
-    if (GetWindowPlacement(hWnd, &g_wpPrev) && GetMonitorInfo(MonitorFromWindow(hWnd, MONITOR_DEFAULTTOPRIMARY), &mi)) {
-      SetWindowPos(hWnd, HWND_TOP, mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.right - mi.rcMonitor.left,
-                   mi.rcMonitor.bottom - mi.rcMonitor.top, SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
-    }
-  } else {
-    SetWindowLong(hWnd, GWL_STYLE, oldWindowStandard);
-    SetWindowLong(hWnd, GWL_EXSTYLE, oldWindowExtended);
-    SetWindowPlacement(hWnd, &g_wpPrev);
-    SetWindowPos(hWnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
-  }
-}
-
-LRESULT __stdcall WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) // WndProc wrapper
-{
-  switch (uMsg) {
-    case WM_KEYUP: {
-      if (wParam == VK_F11) {
-        ToggleFullscreen(hWnd);
-      }
-    } break;
-  }
-  return CallWindowProcW((WNDPROC)oWndProc, hWnd, uMsg, wParam, lParam);
-}
-
-decltype(SetWindowLongW)* oSetWindowLong = nullptr;
-LONG                      SetWindowLongW_Hook(_In_ HWND hWnd, _In_ int nIndex, _In_ LONG dwNewLong)
-{
-  if (nIndex == GWL_STYLE) {
-    char clsName_v[256];
-    GetClassNameA(hWnd, clsName_v, 256);
-    if (clsName_v == std::string("UnityWndClass")) {
-      unityWindow = hWnd;
-      if (Config::Get().free_resize) {
-        if (!(dwNewLong & WS_POPUP)) {
-          dwNewLong = WS_OVERLAPPEDWINDOW;
-        }
-      }
-
-      if (!WndProcInstalled) {
-        if (Config::Get().borderless_fullscreen) {
-          oWndProc         = SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)WndProc);
-          WndProcInstalled = true;
-        }
-      }
-    }
-  }
-  return SetWindowLong(hWnd, nIndex, dwNewLong);
-}
-
-struct Resolution {
-  int m_Width;
-  int m_Height;
-  int m_RefreshRate;
-};
-
-void AspectRatioConstraintHandler_Update(auto original, void* _this)
-{
-  static auto set_title       = true;
-  static auto get_fullscreen  = il2cpp::ResolveICall<bool()>("UnityEngine.Screen::get_fullScreen()");
-  static auto get_height      = il2cpp::ResolveICall<int()>("UnityEngine.Screen::get_height()");
-  static auto get_width       = il2cpp::ResolveICall<int()>("UnityEngine.Screen::get_width()");
-  static auto SetResolution   = il2cpp::ResolveICall<void(int, int, int, int)>(
-      "UnityEngine.Screen::SetResolution(System.Int32,System.Int32,UnityEngine.FullScreenMode,System.Int32)");
-
-  if (unityWindow) {
-    if (get_fullscreen()) {
-      static auto get_currentResolution_Injected = il2cpp::ResolveICall<void(Resolution*)>(
-          "UnityEngine.Screen::get_currentResolution_Injected(UnityEngine.Resolution&)");
-      auto       height = get_height();
-      auto       width  = get_width();
-      Resolution res;
-      get_currentResolution_Injected(&res);
-
-      MONITORINFO mi = {sizeof(mi)};
-      GetWindowPlacement(unityWindow, &g_wpPrev)
-          && GetMonitorInfo(MonitorFromWindow(unityWindow, MONITOR_DEFAULTTOPRIMARY), &mi);
-      auto m_width  = mi.rcMonitor.right - mi.rcMonitor.left;
-      auto m_height = mi.rcMonitor.bottom - mi.rcMonitor.top;
-      if (m_width != 1024 && m_height != 768 && width == 1024 && height == 768) {
-        if (m_width != width || m_width != height) {
-          SetResolution(m_width, m_height, 1, res.m_RefreshRate);
-        }
-      }
-    }
-  }
-
-#if _WIN32
-  if (set_title) {
-    auto title = File::Title();
-    if (!title.empty()) {
-      if (WindowTitle::Set(title)) {
-        set_title = false;
-      }
-    }
-  }
-#endif
-
-  // SetResolution(1920, 1080, 4, 60);
-}
-
-intptr_t AspectRatioConstraintHandler_WndProc(auto original, HWND hWnd, uint32_t msg, intptr_t wParam, intptr_t lParam)
-{
-  if (Config::Get().free_resize) {
-    return CallWindowProcA(AspectRatioConstraintHandler::_unityWndProc(), hWnd, msg, wParam, lParam);
-  }
-  return original(hWnd, msg, wParam, lParam);
-}
-
-void InstallFreeResizeHooks()
-{
-  auto update  = AspectRatioConstraintHandler::Class::Method("Update");
-  auto wndproc = AspectRatioConstraintHandler::Class::Method("WndProc");
-  if (!update || !wndproc)
-    return;
-
-  SPUD_STATIC_DETOUR(update.Pointer(), AspectRatioConstraintHandler_Update);
-  SPUD_STATIC_DETOUR(wndproc.Pointer(), AspectRatioConstraintHandler_WndProc);
-}
-#endif
diff --git a/mods/src/patches/parts/galactic_anomaly_timer.cc b/mods/src/patches/parts/galactic_anomaly_timer.cc
index b1727ff9b..e374ef10d 100644
--- a/mods/src/patches/parts/galactic_anomaly_timer.cc
+++ b/mods/src/patches/parts/galactic_anomaly_timer.cc
@@ -1,389 +1,234 @@
+// galactic_anomaly_timer: a countdown for the active galactic anomaly in the viewed system, under the HUD's
+// Help All / Engage / Claim drawer. All Unity work runs on the frame tick; there are no detours of its own.
+
 #include "config.h"
-#include "patches/screen_update_hook.h"
+#include "patches/patches.h"
 
-#include <prime/Color.h>
-#include <prime/Component.h>
-#include <prime/GameObject.h>
-#include <prime/Hub.h>
-#include <prime/Image.h>
-#include <prime/RectTransform.h>
-#include <prime/ScreenManager.h>
-#include <prime/Transform.h>
-#include <prime/Vector2.h>
+#include "prime/Hub.h"
+#include "prime/hud.h"
+#include "prime/ui.h"
 
 #include <il2cpp/il2cpp.h>
 #include <spdlog/spdlog.h>
+#include <unity/ui.h>
 
 #include <chrono>
 #include <cstdint>
-#include <string>
+#include <utility>
 
 namespace
 {
-// All Unity work runs on ScreenManager's main-thread dispatcher. No additional detours.
-
-using UnityObject = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Object">;
-
-struct TimeSpan {
-  int64_t ticks;
-};
-
-struct TextMeshProUGUI : Component {
-  using Class = il2cpp::Class<"Unity.TextMeshPro", "TMPro", "TextMeshProUGUI">;
-
-  // TMP_FontAsset
-  il2cpp::Object* font()
-  { return Get<"font", il2cpp::Object*>(); }
-  void SetFont(il2cpp::Object* value)
-  { Set<"font">(value); }
-  void SetFontSize(float value)
-  { Set<"fontSize">(value); }
-  // TextAlignmentOptions
-  void SetAlignment(int32_t value)
-  { Set<"alignment">(value); }
-  void SetColor(color value)
-  { Set<"color">(value); }
-  void SetRaycastTarget(bool value)
-  { Set<"raycastTarget">(value); }
-  void SetEnableWordWrapping(bool value)
-  { Set<"enableWordWrapping">(value); }
-  void SetText(Il2CppString* value)
-  { Set<"text">(value); }
-};
-
-struct FactionInformation : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "FactionInformation">;
-
-  // TextLocalizer components, one per system name label.
-  il2cpp::List<Component*>* systemName()
-  { return Field<"_systemName", il2cpp::List<Component*>*>(); }
-};
-
-struct HudNavigationViewController : Component {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation.UI", "HudNavigationViewController">;
-
-  Component* galacticAnomaliesButtonWidget()
-  { return Field<"_galacticAnomaliesButtonWidget", Component*>(); }
-  FactionInformation* factionInformationHelper()
-  { return Field<"_factionInformationHelper", FactionInformation*>(); }
-  bool isActiveAndEnabled()
-  { return Get<"isActiveAndEnabled", bool>(); }
-  bool CanShowGalacticAnomaly()
-  { return Call<"CanShowGalacticAnomaly", bool>(); }
-  // NavigationViewData. It and the server models below are read on their runtime classes.
-  il2cpp::Object* CanvasContext()
-  { return Get<"CanvasContext", il2cpp::Object*>(); }
-};
-
-struct HudAllianceAndNewsViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "HudAllianceAndNewsViewController">;
+using Clock = std::chrono::steady_clock;
 
-  Component* chestPromotion()
-  { return Field<"_chestPromotion", Component*>(); }
-};
-
-// The data contexts the two HUD canvases are registered with.
-struct NavigationViewData : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationViewData">;
-};
-struct HudAllianceAndNewsViewControllerContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "HudAllianceAndNewsViewControllerContext">;
-};
-
-struct GalacticAnomaliesManager : MonoSingleton<GalacticAnomaliesManager> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.GalacticAnomalies", "GalacticAnomaliesManager">;
-
-  // Digit.PrimeServer.Models.GalacticAnomaly, or null.
-  il2cpp::Object* GetSystemGalacticAnomalies(int64_t system)
-  { return Call<"GetSystemGalacticAnomalies", il2cpp::Object*>(system); }
-};
-
-bool Alive(Il2CppObject* object)
-{ return object && UnityObject::Call<"op_Implicit", bool>(object); }
-
-void Destroy(Il2CppObject* object)
-{ UnityObject::Call<"Destroy">(object); }
-
-// The first active T on `root`'s GameObject or below it. Scoped to one hierarchy, unlike FindObjectOfType, which
-// scans every loaded object.
-template <typename T> T* FindInChildren(il2cpp::Object* root)
+// The rounded key-hint background next to the native anomaly button, reused for the panel.
+unity::Sprite* NativeBackgroundSprite(HudNavigationViewController* nav)
 {
-  auto* type = T::Class::TypeObject();
-  return root && type ? root->Call<"GetComponentInChildren", T*>(type, false) : nullptr;
+  auto* button     = nav->galacticAnomaliesButtonWidget();
+  auto* transform  = button ? button->transform() : nullptr;
+  auto* parent     = transform ? transform->parent() : nullptr;
+  auto* background = parent ? parent->Find("ShortcutKeybindHint/Background") : nullptr;
+  auto* object     = background ? background->gameObject() : nullptr;
+  auto* image      = object ? object->GetComponent<unity::Image>() : nullptr;
+  if (!image)
+    return nullptr;
+  // ImageSelector applies localized artwork through overrideSprite.
+  auto* sprite = image->overrideSprite();
+  return sprite ? sprite : image->sprite();
 }
 
-// The first live T on a visible registered canvas whose context is a `Context`. Only the canvas that owns that
-// context is searched: the top interaction canvas and its root can belong to unrelated overlays.
-template <typename T, typename Context> T* RegisteredController()
+unity::Image* AddImage(unity::GameObject* object, unity::Color tint, unity::Sprite* sprite)
 {
-  auto*   screenManager = ScreenManager::Existing();
-  auto*   screens       = Alive(screenManager) ? screenManager->screens() : nullptr;
-  int32_t count         = screens ? screens->Count() : 0;
-  if (count < 0 || count > 256)
+  auto* image = object->AddComponent<unity::Image>();
+  if (!image)
     return nullptr;
-  for (int32_t index = 0; index < count; ++index) {
-    auto* canvas  = (*screens)[index];
-    auto* context = Alive(canvas) ? canvas->Context() : nullptr;
-    if (!context || !context->Is<Context>() || !canvas->Visible())
-      continue;
-    if (auto* controller = FindInChildren<T>(canvas); Alive(controller))
-      return controller;
+  image->SetColor(tint);
+  image->SetRaycastTarget(false);
+  if (sprite && sprite->pixelsPerUnit() > 0) {
+    image->SetSprite(sprite);
+    image->SetType(unity::Image::Type::Sliced);
+    image->SetPixelsPerUnitMultiplier(100 / sprite->pixelsPerUnit());
   }
-  return nullptr;
+  return image;
 }
 
-HudNavigationViewController* NavigationHud()
-{ return RegisteredController<HudNavigationViewController, NavigationViewData>(); }
-
-il2cpp::GcHandle navigation, panel, label, anomalyManager;
-int64_t          renderedSeconds = -1;
-
-void Clear()
+// The countdown panel under the upper-right Help All / Engage / Claim drawer. Parenting to the drawer follows its
+// scale and visibility without moving any native button.
+class AnomalyTimer
 {
-  if (auto* go = panel.Get<GameObject>(); Alive(go)) {
-    go->SetActive(false);
-    Destroy(go);
-  }
-  label.Reset();
-  panel.Reset();
-  navigation.Reset();
-  anomalyManager.Reset();
-  renderedSeconds = -1;
-}
+public:
+  void Update()
+  {
+    const auto now = Clock::now();
+    if (now < next_update_)
+      return;
+    next_update_ = now + std::chrono::milliseconds(250);
+    if (!Config::Get().graphics.galactic_anomaly_timer) {
+      DestroyPanel();
+      navigation_.Reset();
+      return;
+    }
 
-void Rect(RectTransform* transform, Vector2 anchor, Vector2 pivot, Vector2 size, Vector2 position)
-{
-  transform->SetAnchorMin(anchor);
-  transform->SetAnchorMax(anchor);
-  transform->SetPivot(pivot);
-  transform->SetSizeDelta(size);
-  transform->SetAnchoredPosition(position);
-}
+    auto* nav = Navigation();
+    // Remaining ticks of the active anomaly in the viewed system.
+    const int64_t ticks = nav && nav->isActiveAndEnabled() && nav->CanShowGalacticAnomaly() ? RemainingTicks(nav) : 0;
+    if (ticks <= 0) {
+      if (auto* label = Label())
+        label->transform()->parent()->gameObject()->SetActive(false);
+      return;
+    }
+    if (!Label() && !Create(nav)) {
+      static bool warned = false;
+      if (!std::exchange(warned, true))
+        spdlog::warn("Galactic anomaly countdown: HUD creation failed; leaving the native HUD unchanged");
+      DestroyPanel();
+      next_update_ = now + std::chrono::seconds(5);
+      return;
+    }
 
-// Creates an inactive GameObject under `parent` and roots it in `root`.
-RectTransform* NewObject(const char* name, Transform* parent, il2cpp::GcHandle& root)
-{
-  auto* object = il2cpp::New<GameObject>(il2cpp_string_new(name));
-  root         = il2cpp::GcHandle::Strong(object);
-  if (!object)
-    return nullptr;
-  object->SetActive(false);
-  auto* transform = object->AddComponent<RectTransform>();
-  if (!transform)
-    return nullptr;
-  transform->SetParent(parent, false);
-  return transform;
-}
+    const auto seconds = ticks / 10'000'000 + (ticks % 10'000'000 != 0);
+    if (seconds != shown_seconds_) {
+      shown_seconds_  = seconds;
+      const auto text = seconds >= 3600
+                            ? fmt::format("{}h {:02}m {:02}s", seconds / 3600, seconds / 60 % 60, seconds % 60)
+                            : fmt::format("{:02}m {:02}s", seconds / 60, seconds % 60);
+      Label()->SetText(text);
+    }
+    Label()->transform()->parent()->gameObject()->SetActive(true);
+  }
 
-Sprite* GraphicSprite(Image* image)
-{
-  if (!image)
-    return nullptr;
-  // ImageSelector applies localized artwork through overrideSprite.
-  auto* sprite = image->overrideSprite();
-  return sprite ? sprite : image->sprite();
-}
+private:
+  // The navigation HUD while the system view is open. It has no singleton; look for it on its registered canvas
+  // whenever the one held is gone or inactive, rather than with FindObjectOfType, which scans every object. The
+  // search walks every registered canvas, so it runs at most once a second, and a held HUD is kept until a
+  // different live one turns up.
+  HudNavigationViewController* Navigation()
+  {
+    if (Hub::CurrentSection() != SectionID::Navigation_System) {
+      DestroyPanel();
+      navigation_.Reset();
+      return nullptr;
+    }
+    auto* held = navigation_.Get<HudNavigationViewController>();
+    if (unity::Alive(held) && held->isActiveAndEnabled())
+      return held;
+    if (const auto now = Clock::now(); now >= next_discovery_) {
+      next_discovery_   = now + std::chrono::seconds(1);
+      auto* replacement = ScreenManager::View<HudNavigationViewController>();
+      if ((replacement && replacement != held) || !unity::Alive(held)) {
+        DestroyPanel();
+        navigation_ = il2cpp::GcHandle::Strong(replacement);
+      }
+    }
+    auto* nav = navigation_.Get<HudNavigationViewController>();
+    return unity::Alive(nav) ? nav : nullptr;
+  }
 
-Sprite* NativeBackgroundSprite(HudNavigationViewController* nav)
-{
-  auto* button     = nav->galacticAnomaliesButtonWidget();
-  auto* transform  = button ? button->transform() : nullptr;
-  auto* parent     = transform ? transform->parent() : nullptr;
-  auto* background = parent ? parent->Find(il2cpp_string_new("ShortcutKeybindHint/Background")) : nullptr;
-  auto* object     = background ? background->gameObject() : nullptr;
-  return object ? GraphicSprite(object->GetComponent<Image>()) : nullptr;
-}
+  unity::TMP_Text* Label()
+  {
+    auto* label = label_.Get<unity::TMP_Text>();
+    return unity::Alive(label) ? label : nullptr;
+  }
 
-void Slice(Image* image, Sprite* sprite)
-{
-  if (!image || !sprite)
-    return;
-  float spritePixels = sprite->pixelsPerUnit();
-  if (spritePixels <= 0)
-    return;
-  image->SetType(Image::Type::Sliced);
-  image->SetPixelsPerUnitMultiplier(100 / spritePixels);
-}
+  void DestroyPanel()
+  {
+    if (auto* label = Label()) {
+      auto* panel = label->transform()->parent()->gameObject();
+      panel->SetActive(false);
+      unity::Destroy(panel);
+    }
+    label_.Reset();
+    shown_seconds_ = -1;
+  }
 
-Image* Decoration(const char* name, Transform* parent, Vector2 size, Vector2 position, color tint,
-                  Sprite* sprite = nullptr)
-{
-  il2cpp::GcHandle object;
-  auto*            transform = NewObject(name, parent, object);
-  auto*            go        = object.Get<GameObject>();
-  auto*            image     = go ? go->AddComponent<Image>() : nullptr;
-  const bool       ok        = transform && image;
-  if (ok) {
-    Rect(transform, {0.5f, 0.5f}, {0.5f, 0.5f}, size, position);
-    image->SetColor(tint);
-    image->SetRaycastTarget(false);
-    if (sprite)
-      image->SetSprite(sprite);
-    go->SetActive(true);
-  } else if (Alive(go)) {
-    Destroy(go);
+  static int64_t RemainingTicks(HudNavigationViewController* nav)
+  {
+    auto*   context = nav->CanvasContext();
+    auto*   address = context ? context->ViewingAddress() : nullptr;
+    int64_t system  = address ? address->System() : -1;
+    auto*   manager = system > 0 ? GalacticAnomaliesManager::Current() : nullptr;
+    auto*   anomaly = manager ? manager->GetSystemGalacticAnomalies(system) : nullptr;
+    if (!anomaly || !anomaly->IsActive())
+      return 0;
+    auto* timer = anomaly->EndTimeTimerDataContext();
+    return timer ? timer->RemainingTime().ticks : 0;
   }
-  return ok ? image : nullptr;
-}
 
-bool Create(HudNavigationViewController* nav)
-{
-  // Keep the native system-name font, but place the timer under the upper-right
-  // Help All / Engage / Claim drawer. Parenting to the drawer follows its scale
-  // and visibility without changing any native button positions.
-  auto* helper = nav->factionInformationHelper();
-  auto* names  = helper ? helper->systemName() : nullptr;
-  if (!names || names->Count() < 1)
-    return false;
-  auto* name = (*names)[0];
-  if (!Alive(name))
-    return false;
-  auto* drawer     = RegisteredController<HudAllianceAndNewsViewController, HudAllianceAndNewsViewControllerContext>();
-  auto* promotion  = drawer ? drawer->chestPromotion() : nullptr;
-  auto* chest      = promotion ? promotion->transform() : nullptr;
-  auto* parent     = chest ? chest->parent() : nullptr;
-  auto* nameObject = name->gameObject();
-  auto* source     = nameObject ? nameObject->GetComponent<TextMeshProUGUI>() : nullptr;
-  auto* font       = source ? source->font() : nullptr;
-  if (!parent || !font)
-    return false;
+  // Builds the panel: the native rounded sprite twice, with a narrow inset making the border, and a countdown in
+  // the system-name font. A missing sprite still gives a visible frame.
+  bool Create(HudNavigationViewController* nav)
+  {
+    auto* helper = nav->factionInformationHelper();
+    auto* names  = helper ? helper->systemName() : nullptr;
+    auto* name   = names && names->Count() > 0 ? (*names)[0] : nullptr;
+    if (!unity::Alive(name))
+      return false;
+    auto* drawer    = ScreenManager::View<HudAllianceAndNewsViewController>();
+    auto* promotion = drawer ? drawer->chestPromotion() : nullptr;
+    auto* chest     = promotion ? promotion->transform() : nullptr;
+    auto* parent    = chest ? chest->parent() : nullptr;
+    auto* source    = name->gameObject() ? name->gameObject()->GetComponent<unity::TextMeshProUGUI>() : nullptr;
+    auto* font      = source ? source->font() : nullptr;
+    if (!parent || !font)
+      return false;
+
+    il2cpp::GcHandle panel, fill, text;
+    auto*            panel_rect = unity::CreateUiObject("CommunityMod_AnomalyTimer", parent, panel);
+    if (!panel_rect)
+      return false;
+    panel_rect->Place({0.5f, 0}, {0.5f, 0}, {0.5f, 1}, {198, 38}, {0, -40});
+    auto* rounded = NativeBackgroundSprite(nav);
+    if (!AddImage(panel.Get<unity::GameObject>(), {0.64f, 0.34f, 0.46f, 0.85f}, rounded))
+      return Abandon(panel);
+
+    auto* fill_rect = unity::CreateUiObject("AnomalyFill", panel_rect, fill);
+    if (!fill_rect || !AddImage(fill.Get<unity::GameObject>(), {0.06f, 0.10f, 0.14f, 0.96f}, rounded))
+      return Abandon(panel);
+    fill_rect->Place({0.5f, 0.5f}, {0.5f, 0.5f}, {0.5f, 0.5f}, {194, 34}, {0, 0});
+    fill.Get<unity::GameObject>()->SetActive(true);
+
+    auto* text_rect = unity::CreateUiObject("Countdown", panel_rect, text);
+    auto* label     = text_rect ? text.Get<unity::GameObject>()->AddComponent<unity::TextMeshProUGUI>() : nullptr;
+    if (!label)
+      return Abandon(panel);
+    text_rect->Place({0.5f, 0.5f}, {0.5f, 0.5f}, {0.5f, 0.5f}, {190, 28}, {0, 0});
+    label->SetFont(font);
+    label->SetFontSize(22);
+    label->SetAlignment(unity::TMP_Text::Alignment::Center);
+    label->SetColor({0.95f, 0.83f, 0.89f, 1});
+    label->SetRaycastTarget(false);
+    label->SetEnableWordWrapping(false);
+    text.Get<unity::GameObject>()->SetActive(true);
+    // The children are owned by the hierarchy once parented; only the label is kept.
+    label_ = il2cpp::GcHandle::Strong(label);
+    return true;
+  }
 
-  auto* transform = NewObject("CommunityMod_AnomalyTimer", parent, panel);
-  auto* panelGo   = panel.Get<GameObject>();
-  if (!transform || !panelGo)
+  static bool Abandon(il2cpp::GcHandle& panel)
+  {
+    if (auto* object = panel.Get<unity::GameObject>(); unity::Alive(object))
+      unity::Destroy(object);
     return false;
-  Rect(transform, {0.5f, 0}, {0.5f, 1}, {198, 38}, {0, -40});
-  auto* background = panelGo->AddComponent<Image>();
-  if (!background)
-    return false;
-  background->SetColor({0.64f, 0.34f, 0.46f, 0.85f});
-  background->SetRaycastTarget(false);
-  // Use the existing native key-hint silhouette for both layers, with a narrow
-  // inset creating the border. A missing sprite still yields a visible frame.
-  auto* rounded = NativeBackgroundSprite(nav);
-  if (rounded) {
-    background->SetSprite(rounded);
-    Slice(background, rounded);
   }
-  auto* fill = Decoration("AnomalyFill", transform, {194, 34}, {0, 0}, {0.06f, 0.10f, 0.14f, 0.96f}, rounded);
-  if (!fill)
-    return false;
-  Slice(fill, rounded);
 
-  il2cpp::GcHandle textObject;
-  auto*            textTransform = NewObject("Countdown", transform, textObject);
-  auto*            textGo        = textObject.Get<GameObject>();
-  auto*            text          = textGo ? textGo->AddComponent<TextMeshProUGUI>() : nullptr;
-  label                          = il2cpp::GcHandle::Strong(text);
-  const bool ok                  = textTransform && text;
-  if (ok) {
-    Rect(textTransform, {0.5f, 0.5f}, {0.5f, 0.5f}, {190, 28}, {0, 0});
-    text->SetFont(font);
-    text->SetFontSize(22);
-    text->SetAlignment(0x202); // TMP: Center (514).
-    text->SetColor({0.95f, 0.83f, 0.89f, 1});
-    text->SetRaycastTarget(false);
-    text->SetEnableWordWrapping(false);
-    textGo->SetActive(true);
-  } else if (Alive(textGo)) {
-    Destroy(textGo);
-  }
-  textObject.Reset(); // The parent hierarchy now owns this child.
-  return ok;
-}
+  il2cpp::GcHandle  navigation_, label_;
+  Clock::time_point next_update_{}, next_discovery_{};
+  int64_t           shown_seconds_ = -1;
+};
 
-// Remaining ticks of the active anomaly in the viewed system, or 0.
-int64_t RemainingTicks(HudNavigationViewController* nav)
+AnomalyTimer* timer = nullptr;
+void          AnomalyTimerUpdate()
 {
-  auto*   context = nav->CanvasContext();
-  auto*   address = context ? context->Get<"ViewingAddress", il2cpp::Object*>() : nullptr;
-  int64_t system  = address ? address->Get<"System", int64_t>() : -1;
-  if (system <= 0)
-    return 0;
-  // Cache the Unity object, not its timer data. Unity's liveness check detects
-  // destruction even while the managed wrapper is retained by our GC handle.
-  if (!Alive(anomalyManager.Get()))
-    anomalyManager = il2cpp::GcHandle::Strong(GalacticAnomaliesManager::Existing());
-  auto* manager = anomalyManager.Get<GalacticAnomaliesManager>();
-  auto* anomaly = Alive(manager) ? manager->GetSystemGalacticAnomalies(system) : nullptr;
-  if (!anomaly || !anomaly->Get<"IsActive", bool>())
-    return 0;
-  auto* timer = anomaly->Get<"EndTimeTimerDataContext", il2cpp::Object*>();
-  return timer ? timer->Get<"RemainingTime", TimeSpan>().ticks : 0;
+  if (timer)
+    timer->Update();
 }
 
-void Update()
+void InstallAnomalyTimer()
 {
-  static auto next = std::chrono::steady_clock::time_point{};
-  auto        now  = std::chrono::steady_clock::now();
-  if (now < next)
-    return;
-  next = now + std::chrono::milliseconds(250);
-
-  if (!Config::Get().galactic_anomaly_timer) {
-    Clear();
-    return;
-  }
-  // The anomaly button only exists in system view.
-  auto* sections = Hub::get_SectionManager();
-  if (!sections || sections->CurrentSection() != SectionID::Navigation_System) {
-    Clear();
-    return;
-  }
-  // Rediscovery walks every registered canvas, so retry at most once a second. A hidden HUD is kept until a
-  // different live one turns up.
-  static auto nextDiscovery = std::chrono::steady_clock::time_point{};
-  auto*       cached        = navigation.Get<HudNavigationViewController>();
-  if ((!Alive(cached) || !cached->isActiveAndEnabled()) && now >= nextDiscovery) {
-    nextDiscovery     = now + std::chrono::seconds(1);
-    auto* replacement = NavigationHud();
-    if ((replacement && replacement != cached) || !Alive(cached)) {
-      Clear();
-      navigation = il2cpp::GcHandle::Strong(replacement);
-    }
-  }
-  auto*   nav   = navigation.Get<HudNavigationViewController>();
-  int64_t ticks = 0;
-  if (Alive(nav) && nav->isActiveAndEnabled() && nav->CanShowGalacticAnomaly())
-    ticks = RemainingTicks(nav);
-  bool show = ticks > 0;
-  if (show && (!Alive(panel.Get()) || !Alive(label.Get()))) {
-    // Release old UI without releasing the current navigation reference.
-    auto* current = nav;
-    Clear();
-    navigation = il2cpp::GcHandle::Strong(current);
-    if (!Create(current)) {
-      static bool warned = false;
-      if (!warned) {
-        spdlog::warn("Galactic anomaly countdown: HUD creation failed; leaving the native HUD unchanged");
-        warned = true;
-      }
-      Clear();
-      next = now + std::chrono::seconds(5);
-      return;
-    }
-  }
-  auto* panelGo = panel.Get<GameObject>();
-  if (!Alive(panelGo))
-    return;
-  if (show) {
-    // Only touch the label when the displayed whole second changes.
-    auto seconds = ticks / 10000000 + (ticks % 10000000 != 0);
-    if (seconds != renderedSeconds) {
-      auto text = seconds >= 3600 ? fmt::format("{}h {:02}m {:02}s", seconds / 3600, seconds / 60 % 60, seconds % 60)
-                                  : fmt::format("{:02}m {:02}s", seconds / 60, seconds % 60);
-      label.Get<TextMeshProUGUI>()->SetText(il2cpp_string_new(text.c_str()));
-      renderedSeconds = seconds;
-    }
-  }
-  panelGo->SetActive(show);
+  // Never destroyed: GC handles must not be released by static destructors after the runtime is gone.
+  timer = new AnomalyTimer;
+  spdlog::info("Galactic anomaly countdown enabled (below Help All / Engage / Claim)");
 }
 } // namespace
 
-void InstallGalacticAnomalyTimer()
-{
-  if (install_screen_manager_update_hook()) {
-    register_screen_manager_update_callback(Update);
-    spdlog::info("Galactic anomaly countdown enabled (below Help All / Engage / Claim)");
-  }
-}
+const Feature kAnomalyTimer{"AnomalyTimer", &Config::Patches::galacticanomalytimerhooks, InstallAnomalyTimer,
+                            AnomalyTimerUpdate};
diff --git a/mods/src/patches/parts/game_config.cc b/mods/src/patches/parts/game_config.cc
new file mode 100644
index 000000000..c5fba9320
--- /dev/null
+++ b/mods/src/patches/parts/game_config.cc
@@ -0,0 +1,31 @@
+// [config] settings_url and assets_url_override: replace the server addresses in the game's own app config as it
+// loads.
+
+#include "config.h"
+#include "patches/patches.h"
+
+#include "prime/Hub.h"
+
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
+
+namespace
+{
+void Model_LoadConfigs_Hook(auto original, Model* _this)
+{
+  original(_this);
+  auto* config = _this->appConfig();
+  if (!config)
+    return;
+  const auto& game = Config::Get().game;
+  if (!game.settings_url.empty())
+    config->SetPlatformSettingsUrl(il2cpp::NewString(game.settings_url.c_str()));
+  if (!game.assets_url_override.empty())
+    config->SetAssetUrlOverride(il2cpp::NewString(game.assets_url_override.c_str()));
+}
+
+void InstallGameConfigOverrides()
+{ IL2CPP_HOOK(Model::Class::Method<void()>("LoadConfigs"), Model_LoadConfigs_Hook); }
+} // namespace
+
+const Feature kGameConfigOverrides{"GameConfigOverrides", &Config::Patches::testpatches, InstallGameConfigOverrides};
diff --git a/mods/src/patches/parts/haven_history.cc b/mods/src/patches/parts/haven_history.cc
index 5952ee63c..8241c9dcd 100644
--- a/mods/src/patches/parts/haven_history.cc
+++ b/mods/src/patches/parts/haven_history.cc
@@ -1,5 +1,4 @@
 #include "config.h"
-#include "errormsg.h"
 
 #include <il2cpp/il2cpp-functions.h>
 #include <il2cpp/il2cpp_helper.h>
@@ -65,7 +64,7 @@ void ReverseRecords(void* records)
 
 void PlanetaryHelpHistoryContext_ApplyRecords_Hook(auto original, void* _this, void* records)
 {
-  if (Config::Get().reverse_haven_history)
+  if (Config::Get().ui.reverse_haven_history)
     ReverseRecords(records);
   original(_this, records);
 }
diff --git a/mods/src/patches/parts/haven_road_depth.cc b/mods/src/patches/parts/haven_road_depth.cc
index d0eb398bf..fad14ee29 100644
--- a/mods/src/patches/parts/haven_road_depth.cc
+++ b/mods/src/patches/parts/haven_road_depth.cc
@@ -1,3 +1,4 @@
+#include <il2cpp/il2cpp.h>
 #include <il2cpp/method_contract.h>
 #include <il2cpp/runtime.h>
 #include <patches/haven_road_cache.h>
@@ -152,7 +153,7 @@ std::string Name(const StrongObject& object)
 {
   StrongObject value(object ? Invoke(Api().name, object.Get()) : nullptr);
   const auto*  string = reinterpret_cast<Il2CppString*>(value.Get());
-  return string && string->length >= 0 && string->length <= 256 ? to_string(string) : std::string{};
+  return string && string->length >= 0 && string->length <= 256 ? il2cpp::ToUtf8(string) : std::string{};
 }
 
 bool IsRoad(const std::string& name)
diff --git a/mods/src/patches/parts/haven_zoom.cc b/mods/src/patches/parts/haven_zoom.cc
index f267e4847..9af66a705 100644
--- a/mods/src/patches/parts/haven_zoom.cc
+++ b/mods/src/patches/parts/haven_zoom.cc
@@ -2,8 +2,7 @@
 
 #include <il2cpp/il2cpp_helper.h>
 #include <il2cpp/method_contract.h>
-#include <prime/Camera.h>
-#include <prime/Vector3.h>
+#include <unity/core.h>
 #include <spdlog/spdlog.h>
 #include <spud/detour.h>
 
@@ -54,12 +53,12 @@ bool ReadHavenRadius(Il2CppObject *provider, float &radius)
          && std::abs(radius - maximum) < 0.01f;
 }
 
-void HavenCamera_UpdateCameraFrame_Hook(auto original, Il2CppObject *provider, Camera *camera)
+void HavenCamera_UpdateCameraFrame_Hook(auto original, Il2CppObject *provider, unity::Camera *camera)
 {
   // Native input, constraints and endpoint updates run first. Only this blend's
   // newly generated output is extended; endpoint assets and normalized LOD stay native.
   original(provider, camera);
-  const auto max_zoom = Config::Get().haven_zoom;
+  const auto max_zoom = Config::Get().graphics.haven_zoom;
   if (provider == nullptr || !std::isfinite(max_zoom) || max_zoom <= 0.0f)
     return;
 
@@ -92,7 +91,7 @@ void HavenCamera_UpdateCameraFrame_Hook(auto original, Il2CppObject *provider, C
       || !std::isfinite(maximum) || !std::isfinite(ratio) || minimum < 0.0f || maximum > 1.0f || maximum <= minimum)
     return;
 
-  Vector3       position{};
+  unity::Vector3 position{};
   HavenRotation ar{}, br{};
   float         af = 0.0f, bf = 0.0f;
   bool          source_orthographic = false, target_orthographic = false, result_orthographic = false;
@@ -289,7 +288,7 @@ void InstallHavenZoomHooks()
   }
   // [patches].havenzoomhooks controls installation independently of haven_zoom.
   if (SPUD_STATIC_DETOUR(update->methodPointer, HavenCamera_UpdateCameraFrame_Hook)) {
-    spdlog::info("[HavenZoom] installed planetary blend camera hook (maximum distance {})", Config::Get().haven_zoom);
+    spdlog::info("[HavenZoom] installed planetary blend camera hook (maximum distance {})", Config::Get().graphics.haven_zoom);
   } else {
     spdlog::warn("[HavenZoom] camera hook was not installed; keeping native zoom range");
   }
diff --git a/mods/src/patches/parts/hotkeys.cc b/mods/src/patches/parts/hotkeys.cc
index 208490b02..461310c2d 100644
--- a/mods/src/patches/parts/hotkeys.cc
+++ b/mods/src/patches/parts/hotkeys.cc
@@ -1,75 +1,19 @@
-#include "config.h"
-#include "patches/object_tracker.h"
-#include "patches/ship_shortcut_hint.h"
-#include "prime/ActivatedAbilityManager.h"
-
-#include <spdlog/spdlog.h>
-#include <spud/detour.h>
-
+// The order the mod's keyboard shortcuts are handled in, each frame from the frame tick in mod.cc, and the hotkey
+// switches: the mode toggles, restart and quit, Escape, and the shortcuts that change a setting. The other
+// shortcuts live with their features: screens.cc, fleet_actions.cc, chat.cc, camera.cc.
 
-// Object Viewers
-#include "prime/AllianceStarbaseObjectViewerWidget.h"
-#include "prime/ArmadaObjectViewerWidget.h"
-#include "prime/WaveDefenseObjectViewerWidget.h"
-#include "prime/CelestialObjectViewerWidget.h"
-#include "prime/EmbassyObjectViewer.h"
-#include "prime/HousingObjectViewerWidget.h"
-#include "prime/MiningObjectViewerWidget.h"
-#include "prime/MissionsObjectViewerWidget.h"
-#include "prime/StarNodeObjectViewerWidget.h"
+#include "config.h"
+#include "patches/patches.h"
+#include "patches/shortcuts.h"
 
-#include "prime/ActionQueueManager.h"
-#include "prime/AnimatedRewardsScreenViewController.h"
-#include "prime/ArtifactHallDetailsViewController.h"
-#include "prime/AssignShipsWidget.h"
-#include "prime/BookmarksManager.h"
-#include "prime/CanvasController.h"
-#include "prime/ChatManager.h"
-#include "prime/DeploymentManager.h"
-#include "prime/ElementSelectorViewController.h"
-#include "prime/FleetBarViewController.h"
-#include "prime/FleetLocalViewController.h"
-#include "prime/FleetsManager.h"
-#include "prime/FullScreenChatViewController.h"
 #include "prime/Hub.h"
-#include "prime/KeyCode.h"
-#include "prime/LanguageManager.h"
-#include "prime/NavigationInteractionUIViewController.h"
-#include "prime/NavigationSectionManager.h"
-#include "prime/OfficerAssignmentViewController.h"
-#include "prime/PlanetaryBaseManager.h"
-#include "prime/PreScanTargetWidget.h"
-#include "prime/ScanEngageButtonsWidget.h"
-#include "prime/ScreenManager.h"
-#include "prime/SelectableList.h"
-#include "prime/ShipManagementViewController.h"
-#include "prime/ShipManagementScreenStateViewController.h"
-#include "prime/ShortcutsManager.h"
-#include "prime/TextLocalizer.h"
-
-#include "patches/parts/action_queue.h"
-#include "patches/key.h"
-#include "patches/mapkey.h"
-#include "patches/parts/daily_faction_bulk_claim.h"
-#include "patches/parts/double_click_assign_ship.h"
-#include "patches/parts/focus_search.h"
-#include "str_utils.h"
-
-#include <il2cpp/il2cpp.h>
+#include "prime/ui.h"
 
-#include "patches/screen_update_hook.h"
-
-#ifdef _MODDBG
-#include "patches/fleet_watch.h"
-#endif
-
-#include <EASTL/vector.h>
+#include <il2cpp/hook.h>
+#include <spdlog/spdlog.h>
+#include <unity/input.h>
 
-#include <array>
-#include <cstdint>
-#include <iostream>
-#include <span>
-#include <string_view>
+#include <chrono>
 
 #ifdef _WIN32
 #include <Windows.h>
@@ -77,1661 +21,183 @@
 
 namespace
 {
-// Classes only the shortcut hint badges touch.
-struct InputAction : il2cpp::Object {
-  using Class = il2cpp::Class<"Unity.InputSystem", "UnityEngine.InputSystem", "InputAction">;
+using Clock = std::chrono::steady_clock;
 
-  Il2CppString* name()
-  { return Get<"name", Il2CppString*>(); }
-};
-
-struct InputActionReference : il2cpp::Object {
-  using Class = il2cpp::Class<"Unity.InputSystem", "UnityEngine.InputSystem", "InputActionReference">;
+bool hotkeys_installed = false;
 
-  InputAction* action()
-  { return Get<"action", InputAction*>(); }
-};
-
-struct ShortcutKeybindHint : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.GameInput", "ShortcutKeybindHint">;
-
-  InputActionReference* inputAction()
-  { return Field<"_inputAction", InputActionReference*>(); }
-  TextLocalizer* keyTextLocalizer()
-  { return Field<"_keyTextLocalizer", TextLocalizer*>(); }
-};
-} // namespace
-
-static bool reset_focus_next_frame            = false;
-static int  show_info_pending                 = 0;
-static int  show_officer_presets_pending      = 0;
-static int  show_officer_swap_pending         = 0;
-static int  show_ship_swap_pending            = 0;
-static bool officer_presets_assignment_opened = false;
-
-using UpdateShortcutHintTextFn = void(ShortcutKeybindHint*);
-
-static UpdateShortcutHintTextFn* original_shortcut_hint_update_text = nullptr;
-static bool                      initialize_actions_hook_ready      = false;
-static bool                      shortcut_hints_ready               = false;
-
-bool SetNativeShortcutHintsVisible(bool visible)
+template <auto Section, auto Setting> void Toggle()
 {
-  auto* shortcuts_manager = ShortcutsManager::Instance();
-  if (!shortcuts_manager) {
-    spdlog::warn("[Hotkeys] native shortcut hints are unavailable");
-    return false;
-  }
-
-  if (shortcuts_manager->ShowKeybindings() != visible)
-    shortcuts_manager->SetShowKeybindings(visible);
-
-  return true;
+  auto& section    = Config::Get().*Section;
+  section.*Setting = !(section.*Setting);
 }
 
-bool ToggleNativeShortcutHints()
+template <spdlog::level::level_enum Level> void SetLogLevel()
 {
-  auto* shortcuts_manager = shortcut_hints_ready ? ShortcutsManager::Instance() : nullptr;
-  if (!shortcuts_manager) {
-    spdlog::warn("[Hotkeys] native shortcut hints are unavailable");
-    return false;
-  }
-
-  // Match the native OnShowKeybindingsAction gate while avoiding a fabricated InputAction.CallbackContext.
-  if (!ShortcutsManager::CanUseShortcuts())
-    return false;
-
-  shortcuts_manager->SetShowKeybindings(!shortcuts_manager->ShowKeybindings());
-
-  return true;
-}
-
-struct NativeShortcutMapping {
-  std::string_view action_name;
-  GameFunction     primary;
-  GameFunction     fallback = GameFunction::Max;
-};
-
-constexpr auto kNativeShortcutMappings = std::to_array<NativeShortcutMapping>({
-    {"interior_view", GameFunction::ShowStationInterior},
-    {"exterior_view", GameFunction::ShoWStationExterior},
-    {"system_view", GameFunction::ShowSystem},
-    {"galaxy_view", GameFunction::ShowGalaxy},
-    {"events", GameFunction::ShowEvents},
-    {"ship_a", GameFunction::SelectShip1},
-    {"ship_b", GameFunction::SelectShip2},
-    {"ship_c", GameFunction::SelectShip3},
-    {"ship_d", GameFunction::SelectShip4},
-    {"ship_e", GameFunction::SelectShip5},
-    {"ship_f", GameFunction::SelectShip6},
-    {"ship_g", GameFunction::SelectShip7},
-    {"ship_h", GameFunction::SelectShip8},
-    {"alliance", GameFunction::ShowAlliance},
-    {"chat", GameFunction::ShowChat},
-    {"side_chat", GameFunction::ShowChatSide1, GameFunction::ShowChatSide2},
-    {"away_teams", GameFunction::ShowAwayTeam},
-    {"missions", GameFunction::ShowMissions},
-    {"daily_goals", GameFunction::ShowDaily},
-    {"ship_locate", GameFunction::SelectCurrent},
-    {"ship_manage", GameFunction::ShowShips},
-    {"research", GameFunction::ShowResearch},
-    {"consumables", GameFunction::ShowExoComp},
-    {"ship_recall", GameFunction::ActionRecall},
-    {"show_keybindings", GameFunction::ToggleShortcutHints},
-    {"gifts", GameFunction::ShowGifts},
-    {"help_alliance", GameFunction::ShowAllianceHelp},
-    {"officers", GameFunction::ShowOfficers},
-    {"factions", GameFunction::ShowFactions},
-    {"items", GameFunction::ShowInventory},
-    {"refinery", GameFunction::ShowRefinery},
-    {"commanders", GameFunction::ShowCommander},
-    {"challenges", GameFunction::ShowQTrials},
-});
-
-consteval bool NativeShortcutActionsAreUnique()
-{
-  for (size_t index = 0; index < kNativeShortcutMappings.size(); ++index) {
-    for (size_t other = index + 1; other < kNativeShortcutMappings.size(); ++other) {
-      if (kNativeShortcutMappings[index].action_name == kNativeShortcutMappings[other].action_name) {
-        return false;
-      }
-    }
-  }
-  return true;
+  spdlog::set_level(Level);
+  spdlog::flush_on(Level);
 }
 
-static_assert(NativeShortcutActionsAreUnique());
-
-constexpr const NativeShortcutMapping* NativeShortcutForAction(std::string_view action_name)
-{
-  for (const auto& mapping : kNativeShortcutMappings) {
-    if (mapping.action_name == action_name) {
-      return &mapping;
-    }
-  }
-  return nullptr;
-}
-
-static_assert(NativeShortcutForAction("interior_view")->primary == GameFunction::ShowStationInterior);
-static_assert(NativeShortcutForAction("side_chat")->fallback == GameFunction::ShowChatSide2);
-static_assert(NativeShortcutForAction("unknown") == nullptr);
-
-void ShortcutKeybindHint_UpdateText_Hook(auto original, ShortcutKeybindHint* _this)
-{
-  if (!_this || !shortcut_hints_ready) {
-    return original(_this);
-  }
-
-  auto* text_localizer = _this->keyTextLocalizer();
-  if (!text_localizer) {
-    return original(_this);
-  }
-
-  // UpdateText does not clear an existing localization override. Clear ours first so native, disabled, and unknown
-  // actions cannot retain a stale mod badge.
-  text_localizer->ClearTextOverride();
-  original(_this);
-
-  const auto& config = Config::Get();
-  if (!config.hotkeys_enabled || config.use_scopely_hotkeys) {
-    return;
-  }
-
-  auto* input_action_reference = _this->inputAction();
-  if (!input_action_reference) {
-    return;
-  }
-
-  auto* action = input_action_reference->action();
-  auto* name   = action ? action->name() : nullptr;
-  if (!name) {
-    return;
-  }
-
-  const auto  action_name = to_string(name);
-  const auto* mapping     = NativeShortcutForAction(action_name);
-  if (!mapping) {
-    text_localizer->OverrideLocalizedText(il2cpp_string_new("-"));
-    return;
-  }
+template <void (*Adjust)(bool), bool Up> void Scale()
+{ Adjust(Up); }
 
-  auto hint_action = mapping->primary;
-  if (hint_action >= GameFunction::SelectShip1 && hint_action <= GameFunction::SelectShip8) {
-    // Use the same context array as FleetBarViewController::RequestSelect(int, bool), not the native dock index.
-    auto* bar     = ObjectFinder<FleetBarViewController>::Get();
-    auto* context = bar ? bar->CanvasContext() : nullptr;
-    auto* fleets  = context ? context->FleetData() : nullptr;
-    hint_action   = ShipShortcutHintAction(hint_action, fleets ? fleets->size() : 0, [fleets](std::size_t position) {
-      auto* fleet = (*fleets)[position];
-      return fleet ? fleet->Index() : -1;
-    });
-  }
-  auto shortcut = hint_action == GameFunction::Max ? std::string{} : MapKey::GetShortcutHint(hint_action);
-  if (shortcut.empty() && mapping->fallback != GameFunction::Max) {
-    shortcut = MapKey::GetShortcutHint(mapping->fallback);
-  }
-  if (shortcut.empty()) {
-    shortcut = "-";
-  }
-  text_localizer->OverrideLocalizedText(il2cpp_string_new(shortcut.c_str()));
-}
+void ReloadSettings()
+{ Config::Reload(); }
 
-void ShortcutKeybindHint_UpdateVisibility_Hook(auto original, ShortcutKeybindHint* _this, bool visible)
-{
-  original(_this, visible);
-  if (visible && shortcut_hints_ready && original_shortcut_hint_update_text) {
-    ShortcutKeybindHint_UpdateText_Hook(original_shortcut_hint_update_text, _this);
-  }
-}
-
-// UnityEngine.InputSystem.InputAction.CallbackContext, passed empty. Generated code takes it by value with the
-// platform's C++ ABI, so this layout must match the managed struct.
-struct InputActionCallbackContext {
-  void*   state;
-  int32_t action_index;
+struct SettingShortcut {
+  Action shortcut;
+  void (*run)();
+  // Held shortcuts repeat every frame while the keys are down; the rest fire once per press.
+  bool held = false;
 };
 
-static_assert(sizeof(InputActionCallbackContext) == 16);
-
-// Calls one of ShortcutsManager's On*Action(InputAction.CallbackContext) handlers. A missing handler is reported
-// once by the binding layer and does nothing.
-template <il2cpp::Name Action> bool InvokeNativeShortcut(const char* action_name)
-{
-  auto* shortcuts_manager = ShortcutsManager::Instance();
-  if (!shortcuts_manager) {
-    spdlog::warn("[Hotkeys] native {} shortcut is unavailable", action_name);
-    return false;
-  }
-
-  shortcuts_manager->Call<Action>(InputActionCallbackContext{});
-  return true;
-}
-
-bool force_space_action_next_frame = false;
-
-void     ChangeNavigationSection(SectionID sectionID);
-void     ExecuteSpaceAction(FleetBarViewController* fleet_bar);
-bool     DidExecuteRecall(FleetBarViewController* fleet_bar);
-bool     DidExecuteRepair(FleetBarViewController* fleet_bar);
-HullType GetHullTypeFromBattleTarget(BattleTargetData* context);
-void     GotoSection(SectionID sectionID, void* screen_data = nullptr);
-bool     CanHideViewers();
-bool     DidHideViewers();
-
-void CycleAutoConfirmInstantWarp(Config& config)
-{
-  const char* state = nullptr;
-  switch (config.auto_confirm_instant_warp) {
-    case InstantWarpConfirmation::None:
-      config.auto_confirm_instant_warp = InstantWarpConfirmation::Warp;
-      state                            = "warp";
-      break;
-    case InstantWarpConfirmation::Warp:
-      config.auto_confirm_instant_warp = InstantWarpConfirmation::Jump;
-      state                            = "jump";
-      break;
-    case InstantWarpConfirmation::Jump:
-      config.auto_confirm_instant_warp = InstantWarpConfirmation::None;
-      state                            = "none";
-      break;
-  }
-
-  spdlog::info("Auto-confirm instant warp set to {}", state);
-}
-
-bool MoveOfficerCanvas(bool goLeft)
-{
-  auto selectors = ObjectFinder<ElementSelectorViewController>::GetAll();
-  if (selectors.empty()) {
-    return false;
-  }
-
-  bool acted = false;
-  for (auto selector : selectors) {
-    if (!selector || !selector->isActiveAndEnabled()) {
-      continue;
-    }
-    if (goLeft) {
-      selector->PressDecrement();
-    } else {
-      selector->PressIncrement();
-    }
-    acted = true;
-  }
-
-  return acted;
-}
-
-bool MoveArtifactCanvas(bool goLeft)
-{
-  bool acted = false;
-  for (auto controller : ObjectFinder<ArtifactHallDetailsViewController>::GetAll()) {
-    if (!controller) {
-      spdlog::trace("MoveArtifactCanvas({}) - No controller", (int)goLeft);
-      continue;
-    }
-
-    if (!controller->isActiveAndEnabled()) {
-      spdlog::trace("MoveArtifactCanvas({}) - Controller not active", (int)goLeft);
-      continue;
-    }
-
-    if (goLeft) {
-      spdlog::debug("MoveArtifactCanvas({}) - Pressing Left Arrow", (int)goLeft);
-      controller->PressLeftArrow();
-    } else {
-      spdlog::debug("MoveArtifactCanvas({}) - Pressing Right Arrow", (int)goLeft);
-      controller->PressRightArrow();
-    }
-    acted = true;
-  }
-
-  return acted;
-}
-
-bool IsRealShipIndex(SelectableList* list, int32_t index)
-{
-  auto* item = list->DataItem(index);
-  if (!item) return false;
-  return static_cast<FleetPlayerData*>(item)->HasShip();
-}
-
-bool MoveShipSelectionInDock(bool goLeft)
-{
-  if (!Config::Get().arrow_keys_to_select_ship) {
-    return false;
-  }
-
-  bool acted = false;
-  for (auto widget : ObjectFinder<AssignShipsWidget>::GetAll()) {
-    if (!widget) continue;
-
-    auto canvas = GetCanvasControllerFromComponent(widget);
-    if (!canvas || !canvas->Visible() || !widget->isActiveAndEnabled()) {
-      spdlog::trace("MoveShipSelectionInDock({}) - widget={} not visible/active", (int)goLeft, (void*)widget);
-      continue;
-    }
-
-    auto* list = widget->selectableList();
-    if (!list) {
-      spdlog::trace("MoveShipSelectionInDock({}) - widget={} has no _selectableList", (int)goLeft, (void*)widget);
-      continue;
-    }
-
-    const auto count = list->Count();
-    if (count <= 0) {
-      spdlog::trace("MoveShipSelectionInDock({}) - list={} count={}", (int)goLeft, (void*)list, count);
-      continue;
-    }
-
-    const auto step = goLeft ? -1 : 1;
-    auto       newIndex = list->SelectedIndex() + step;
-    while (newIndex >= 0 && newIndex < count && !IsRealShipIndex(list, newIndex)) {
-      newIndex += step;
-    }
-    if (newIndex < 0 || newIndex >= count) {
-      spdlog::trace("MoveShipSelectionInDock({}) - no further real ship in that direction", (int)goLeft);
-      continue;
-    }
-
-    spdlog::debug("MoveShipSelectionInDock({}) - selecting index {} of {}", (int)goLeft, newIndex, count);
-    list->RequestSelect(newIndex);
-    acted = true;
-  }
-
-  return acted;
-}
+// Shortcuts that change a setting. The game sees their keys too. The first pressed one runs.
+constexpr SettingShortcut kSettings[] = {
+    {Action::kUiScaleUp, Scale<AdjustUiScale, true>, true},
+    {Action::kUiScaleDown, Scale<AdjustUiScale, false>, true},
+    {Action::kUiShipScaleUp, Scale<AdjustUiShipScale, true>, true},
+    {Action::kUiShipScaleDown, Scale<AdjustUiShipScale, false>, true},
+    {Action::kUiViewerScaleUp, Scale<AdjustUiViewerScale, true>, true},
+    {Action::kUiViewerScaleDown, Scale<AdjustUiViewerScale, false>, true},
+    {Action::kToggleAutoConfirmInstantWarp, CycleInstantWarpConfirmation},
+    {Action::kTogglePreviewLocate, Toggle<&Config::ui, &Config::Ui::disable_preview_locate>},
+    {Action::kTogglePreviewRecall, Toggle<&Config::ui, &Config::Ui::disable_preview_recall>},
+    {Action::kToggleCargoDefault, Toggle<&Config::ui, &Config::Ui::show_cargo_default>},
+    {Action::kToggleCargoPlayer, Toggle<&Config::ui, &Config::Ui::show_player_cargo>},
+    {Action::kToggleCargoStation, Toggle<&Config::ui, &Config::Ui::show_station_cargo>},
+    {Action::kToggleCargoHostile, Toggle<&Config::ui, &Config::Ui::show_hostile_cargo>},
+    {Action::kToggleCargoArmada, Toggle<&Config::ui, &Config::Ui::show_armada_cargo>},
+    {Action::kLogLevelOff, SetLogLevel<spdlog::level::off>},
+    {Action::kLogLevelError, SetLogLevel<spdlog::level::err>},
+    {Action::kLogLevelWarn, SetLogLevel<spdlog::level::warn>},
+    {Action::kLogLevelInfo, SetLogLevel<spdlog::level::info>},
+    {Action::kLogLevelDebug, SetLogLevel<spdlog::level::debug>},
+    {Action::kLogLevelTrace, SetLogLevel<spdlog::level::trace>},
+    {Action::kReloadSettings, ReloadSettings},
+};
 
-void UpdateManageShipDockSelection()
+void SettingShortcuts()
 {
-  static uint64_t last_fleet_id = 0;
-  static auto next_update = std::chrono::steady_clock::time_point{};
-  const auto now = std::chrono::steady_clock::now();
-  if (now < next_update)
-    return;
-  next_update = now + std::chrono::milliseconds(100);
-  auto* sections = Hub::get_SectionManager();
-  if (!Config::Get().dock_syncmanagement || !sections
-      || sections->CurrentSection() != SectionID::ShipManagement_Details) {
-    last_fleet_id = 0;
-    return;
-  }
-  for (auto* controller : ObjectFinder<ShipManagementViewController>::GetAll()) {
-    if (!controller || !controller->isActiveAndEnabled())
-      continue;
-    auto* canvas = GetCanvasControllerFromComponent(controller);
-    if (!canvas || !canvas->Visible())
-      continue;
-    auto* context = controller->Context();
-    auto* fleet = context ? context->CurrentFleet() : nullptr;
-    auto* manager = FleetsManager::Instance();
-    if (!fleet || !fleet->HasShip() || !manager || !manager->HasFleetService())
-      continue;
-    const auto index = fleet->Index();
-    if (index < 0)
-      continue;
-    // Exclude unassigned and synthetic fleets; management list order is not dock order.
-    auto* dock_fleet = manager->GetFleetPlayerData(index);
-    if (!dock_fleet || dock_fleet->Id() != fleet->Id())
-      continue;
-    if (last_fleet_id == fleet->Id())
-      return;
-    auto* bar = ObjectFinder<FleetBarViewController>::Get();
-    if (!bar)
+  for (const auto& setting : kSettings) {
+    if (setting.held ? Shortcut::IsPressed(setting.shortcut) : Shortcut::IsDown(setting.shortcut)) {
+      setting.run();
       return;
-    if (!bar->IsIndexSelected(index)) {
-      // Use the bar's selection flow to update both the highlight and fleet panel.
-      bar->RequestSelect(index);
-      if (!bar->IsIndexSelected(index))
-        return; // Retry next update if native selection was blocked.
-      spdlog::debug("[ManageShips] selected dock {} for fleet {}", index + 1, fleet->Id());
     }
-    last_fleet_id = fleet->Id();
-    return;
   }
-  last_fleet_id = 0;
 }
 
-void UpdateExpiredAbilityButtons()
+// With disable_escape_exit, Escape no longer reaches the game's exit prompt. disable_escape_exit_timer > 0 lets
+// a double tap within that many milliseconds through. Returns true when Escape is swallowed.
+bool SwallowEscape()
 {
-  static auto next_update = std::chrono::steady_clock::time_point{};
-  const auto now = std::chrono::steady_clock::now();
-  if (now < next_update)
-    return;
-  next_update = now + std::chrono::milliseconds(250);
-  auto* bar = ObjectFinder<FleetBarViewController>::Get();
-  auto* controller = bar ? bar->fleetPanelController() : nullptr;
-  auto* fleet = controller ? controller->fleet() : nullptr;
-  if (!fleet || (static_cast<int>(fleet->CurrentState()) & static_cast<int>(FleetState::CanActivateAbility)) == 0)
-    return;
-  auto* manager = ActivatedAbilityManager::Instance();
-  auto* panel = controller->shipActionPanelLocalViewController();
-  auto* canvas = panel ? GetCanvasControllerFromComponent(panel) : nullptr;
-  if (!manager || !canvas || !canvas->Visible() || panel->HasShipAnActiveAbilityWithActiveEffect())
-    return;
-  auto* ids = panel->abilityIDs();
-  auto* buttons = panel->buttons();
-  if (!ids || !buttons)
-    return;
-  for (size_t index = 0; index < ids->size() && index < buttons->size(); ++index) {
-    auto* button = (*buttons)[index];
-    auto* context = button ? button->Context() : nullptr;
-    if (!button || !button->isActiveAndEnabled() || !context || context->Interactable())
-      continue;
-    const auto ability_id = (*ids)[index];
-    auto* timer = panel->GetRemainingCooldown(ability_id);
-    // TimeSpan is an eight-byte value in 100 ns ticks. Repair at -1 second or below.
-    if (timer && timer->RemainingTime().ticks <= -10000000 && manager->CanUseAbility(fleet, ability_id))
-      context->SetInteractable(true);
-  }
-}
-
-bool MoveDockInManagementView(bool goLeft)
-{
-  if (!Config::Get().arrow_keys_to_select_ship) {
-    return false;
-  }
-
-  auto* section_manager = Hub::get_SectionManager();
-  if (!section_manager || section_manager->CurrentSection() != SectionID::ShipManagement_Details) {
+  const auto& config = Config::Get();
+  if (!config.ui.disable_escape_exit || !unity::Key::Pressed(unity::KeyCode::Escape))
     return false;
-  }
-
-  bool acted = false;
-  for (auto controller : ObjectFinder<ShipManagementViewController>::GetAll()) {
-    if (!controller || !controller->isActiveAndEnabled()) {
-      continue;
-    }
-
-    auto canvas = GetCanvasControllerFromComponent(controller);
-    if (!canvas || !canvas->Visible()) {
-      spdlog::trace("MoveDockInManagementView({}) - controller={} not visible", (int)goLeft, (void*)controller);
-      continue;
-    }
-
-    auto* context = controller->Context();
-    if (!context) {
-      spdlog::trace("MoveDockInManagementView({}) - controller={} has no context", (int)goLeft,
-                    (void*)controller);
-      continue;
-    }
-
-    const int32_t count   = context->ListCount();
-    const int32_t current = context->CurrentIndex();
-    if (count <= 1 || current < 0) {
-      spdlog::trace("MoveDockInManagementView({}) - context={} index={} count={}", (int)goLeft, (void*)context,
-                    current, count);
-      continue;
-    }
-
-    const auto next = current + (goLeft ? -1 : 1);
-    if (next < 0 || next >= count) {
-      spdlog::trace("MoveDockInManagementView({}) - no further dock (index={} count={})", (int)goLeft, current, count);
-      continue;
-    }
-
-    spdlog::debug("MoveDockInManagementView({}) - switching dock {} -> {}", (int)goLeft, current, next);
-    context->SetLastMovementWasToIncrement(!goLeft);
-    context->SetCurrentIndex(next);
-    acted = true;
-  }
-
-  return acted;
-}
-
-bool PressShipSwapButton()
-{
-  for (auto controller : ObjectFinder<ShipManagementScreenStateViewController>::GetAll()) {
-    if (!controller) {
-      continue;
-    }
-
-    auto canvas = GetCanvasControllerFromComponent(controller);
-    if (!canvas || !canvas->Visible() || !controller->isActiveAndEnabled()) {
-      continue;
-    }
-
-    auto* button = controller->swapShipButton();
-    if (button) {
-      spdlog::info("[ShipSwap] pressing swap button controller={} button={}", static_cast<void*>(controller),
-                   static_cast<void*>(button));
-      button->Press();
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool PressOfficerSwapButton()
-{
-  for (auto controller : ObjectFinder<ShipManagementScreenStateViewController>::GetAll()) {
-    if (!controller) {
-      continue;
-    }
-
-    auto canvas = GetCanvasControllerFromComponent(controller);
-    if (!canvas || !canvas->Visible() || !controller->isActiveAndEnabled()) {
-      continue;
-    }
-
-    auto* button = controller->officerIconButton();
-    if (button) {
-      spdlog::info("[OfficerSwap] pressing officer button controller={} button={}", static_cast<void*>(controller),
-                   static_cast<void*>(button));
-      button->Press();
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool PressOfficerPresetsButton()
-{
-  for (auto controller : ObjectFinder<OfficerAssignmentViewController>::GetAll()) {
-    if (!controller) {
-      continue;
-    }
-
-    auto canvas = GetCanvasControllerFromComponent(controller);
-    if (!canvas || !canvas->Visible() || !controller->isActiveAndEnabled()) {
-      continue;
-    }
+  // A held key stays swallowed; only distinct presses count towards a double tap.
+  if (config.ui.disable_escape_exit_timer <= 0 || !unity::Key::Down(unity::KeyCode::Escape))
+    return true;
 
-    auto* button = controller->officerPresetsButton();
-    auto* listener = button ? button->SemaphoreListener() : nullptr;
-    auto* native_button = listener ? listener->TheButton() : nullptr;
-    if (native_button) {
-      spdlog::info("[OfficerPresets] pressing presets button controller={} button={}",
-                   static_cast<void*>(controller), static_cast<void*>(button));
-      native_button->Press();
-      return true;
-    }
+  static Clock::time_point first_press{};
+  const auto               now = Clock::now();
+  if (first_press == Clock::time_point{}
+      || now - first_press > std::chrono::milliseconds(config.ui.disable_escape_exit_timer)) {
+    first_press = now;
+    return true;
   }
-
+  // Consume the pair so a quick third press starts a new one.
+  first_press = {};
   return false;
 }
 
-void ScreenManager_Update_Hook(auto original, ScreenManager* _this)
+// The shortcut dispatch for one frame. Returns true when the game's Update must not run, so it does not also
+// handle the key.
+bool DispatchShortcuts()
 {
-  dispatch_screen_manager_update_callbacks();
-  if (!Config::Get().installHotkeyHooks) {
-    return original(_this);
-  }
-
-  UpdateManageShipDockSelection();
-  UpdateExpiredAbilityButtons();
-
-  // This function is called every frame to update the screen manager.
-  // Create a global clock to detect time elapsed
-  static std::chrono::time_point<std::chrono::steady_clock> select_clock             = std::chrono::steady_clock::now();
-  static int32_t                                            last_ship_select_request = -1;
+  auto& config = Config::Get();
 
-  Key::ResetCache();
-
-  if (MapKey::IsDown(GameFunction::DisableHotKeys)) {
-    if (shortcut_hints_ready) {
-      SetNativeShortcutHintsVisible(false);
-    }
-    Config::Get().hotkeys_enabled = false;
+  if (Shortcut::IsDown(Action::kDisableHotKeys)) {
+    HideKeybindBadges();
+    config.control.hotkeys_enabled = false;
     spdlog::warn("Setting hotkeys to DISABLED");
-    return;
-  } else if (MapKey::IsDown(GameFunction::EnableHotKeys)) {
-    Config::Get().hotkeys_enabled = true;
-    spdlog::warn("Setting hotkeys to ENABLED");
-    return;
-  }
-
-  // Per-frame driver - must run every frame, before the hotkey-mode
-  // early-returns below (it must also run in Scopely-hotkey mode and
-  // while hotkeys are toggled off).
-  AssignShipEnterKeyUpdate();
-
-  if (show_officer_presets_pending > 0) {
-    if (PressOfficerPresetsButton()) {
-      show_officer_presets_pending       = 0;
-      officer_presets_assignment_opened = false;
-      return;
-    }
-
-    if (!officer_presets_assignment_opened && PressOfficerSwapButton()) {
-      officer_presets_assignment_opened = true;
-    }
-
-    if (--show_officer_presets_pending == 0) {
-      officer_presets_assignment_opened = false;
-      spdlog::warn("[Hotkeys] timed out waiting for the Officer Presets button");
-    }
-  }
-
-  if (show_officer_swap_pending > 0) {
-    if (PressOfficerSwapButton()) {
-      show_officer_swap_pending = 0;
-      return;
-    }
-
-    if (--show_officer_swap_pending == 0) {
-      spdlog::warn("[Hotkeys] timed out waiting for the Officer Swap button");
-    }
-  }
-
-  if (show_ship_swap_pending > 0) {
-    if (PressShipSwapButton()) {
-      show_ship_swap_pending = 0;
-      return;
-    }
-
-    if (--show_ship_swap_pending == 0) {
-      spdlog::warn("[Hotkeys] timed out waiting for the Ship Swap button");
-    }
+    return true;
   }
-
-  if (Config::Get().use_scopely_hotkeys && Config::Get().hotkeys_enabled) {
-    return original(_this);
+  if (Shortcut::IsDown(Action::kEnableHotKeys)) {
+    config.control.hotkeys_enabled = true;
+    spdlog::warn("Setting hotkeys to ENABLED");
+    return true;
   }
 
-  if (!Config::Get().hotkeys_enabled) {
-    return;
-  }
+  if (PressAwaitedButton())
+    return true;
 
-  if (shortcut_hints_ready && MapKey::IsDown(GameFunction::ToggleShortcutHints)) {
-    ToggleNativeShortcutHints();
-    return;
-  }
+  // Switched off, or with Scopely's (the game's own) hotkeys, the mod leaves the keys to the game. Returning true
+  // here would skip the game's ScreenManager.Update, which also runs the back button, orientation and the rest of
+  // the UI's per-frame work.
+  if (!config.control.hotkeys_enabled || config.control.use_scopely_hotkeys)
+    return false;
 
-  const auto is_in_chat = Hub::IsInChat();
-  const auto config     = &Config::Get();
+  // Keys typed into a text field (chat, search) are text, not shortcuts.
+  const bool typing = unity::Key::IsInputFocused();
+  if (!typing && Shortcut::IsDown(Action::kToggleShortcutHints) && ToggleKeybindBadges())
+    return true;
 
-  if (MapKey::IsDown(GameFunction::Restart)) {
+  if (!typing && Shortcut::IsDown(Action::kRestart)) {
     spdlog::info("Clearing localisation cache and restarting");
     LanguageManager::ClearCache();
-    Hub::get_App()->Reload();
-    return;
+    Hub::App()->Reload();
+    return true;
   }
-
+  if (!typing && Shortcut::IsDown(Action::kQuit)) {
 #ifdef _WIN32
-  if (MapKey::IsDown(GameFunction::Quit)) {
     TerminateProcess(GetCurrentProcess(), 1);
-  }
-#elif defined(__APPLE__)
-  if (MapKey::IsDown(GameFunction::Quit)) {
-    Hub::get_App()->Quit();
-    return;
-  }
+#else
+    Hub::App()->Quit();
+    return true;
 #endif
-
-  int32_t ship_select_request = -1;
-  if (MapKey::IsDown(GameFunction::SelectShip1)) {
-    ship_select_request = 0;
-  } else if (MapKey::IsDown(GameFunction::SelectShip2)) {
-    ship_select_request = 1;
-  } else if (MapKey::IsDown(GameFunction::SelectShip3)) {
-    ship_select_request = 2;
-  } else if (MapKey::IsDown(GameFunction::SelectShip4)) {
-    ship_select_request = 3;
-  } else if (MapKey::IsDown(GameFunction::SelectShip5)) {
-    ship_select_request = 4;
-  } else if (MapKey::IsDown(GameFunction::SelectShip6)) {
-    ship_select_request = 5;
-  } else if (MapKey::IsDown(GameFunction::SelectShip7)) {
-    ship_select_request = 6;
-  } else if (MapKey::IsDown(GameFunction::SelectShip8)) {
-    ship_select_request = 7;
-  }
-
-  if (ship_select_request != -1 && !Key::IsInputFocused()) {
-
-    // TODO: Shift+ship towing with the Discovery never ran on earlier clients (its PlanCourse and
-    // SetTowRequest bindings had drifted) and has not been tested in game since they were fixed. It sends a
-    // real tow request, so keep it off until someone verifies it. Shift+ship falls through as a no-op meanwhile.
-    constexpr bool kEnableDiscoveryTow = false;
-    if (Key::HasShift()) {
-      if constexpr (kEnableDiscoveryTow) {
-        FleetPlayerData* foundDisco = nullptr;
-        for (int discoIdx = 0; discoIdx < 10; ++discoIdx) {
-          auto fleetPlayerData = FleetsManager::Instance()->GetFleetPlayerData(discoIdx);
-          if (fleetPlayerData && fleetPlayerData->Hull() && fleetPlayerData->Hull()->Id() == 1307832955) {
-            foundDisco = fleetPlayerData;
-            break;
-          }
-        }
-
-        if (foundDisco) {
-          auto* towed      = FleetsManager::Instance()->GetFleetPlayerData(ship_select_request);
-          auto* deployment = DeploymentManger::Instance();
-          auto* plannedCourse =
-              towed && deployment ? deployment->PlanCourse(towed, foundDisco->Address(), Vector3::zero(), nullptr,
-                                                           nullptr, nullptr)
-                                  : nullptr;
-          if (plannedCourse) {
-            // Drain the planning coroutine synchronously. The bound stops a coroutine that keeps yielding
-            // (it waits on something only the game loop advances) from hanging the frame.
-            for (int step = 0; step < 1000 && plannedCourse->MoveNext(); ++step) {
-            }
-            deployment->SetTowRequest(towed->Id(), foundDisco->Id());
-          }
-        }
-      }
-    } else {
-      auto fleet_bar  = ObjectFinder<FleetBarViewController>::Get();
-      auto can_locate = !config->disable_preview_locate || !CanHideViewers();
-      if (fleet_bar) {
-        std::chrono::time_point<std::chrono::steady_clock> select_now = std::chrono::steady_clock::now();
-        std::chrono::milliseconds                          select_diff =
-            std::chrono::duration_cast<std::chrono::milliseconds>(select_now - select_clock);
-        spdlog::debug("select_diff was {}ms", select_diff.count());
-        if (can_locate && ship_select_request == last_ship_select_request
-            && fleet_bar->IsIndexSelected(ship_select_request)
-            && select_diff < std::chrono::milliseconds((int)Config::Get().select_timer)) {
-          auto fleet_controller = fleet_bar->fleetPanelController();
-          auto fleet            = fleet_controller ? fleet_controller->fleet() : nullptr;
-          if (!fleet) {
-            return;
-          }
-          if (NavigationSectionManager::Instance() && NavigationSectionManager::Instance()->SNavigationManager()) {
-            NavigationSectionManager::Instance()->SNavigationManager()->HideInteraction();
-          }
-          FleetsManager::Instance()->RequestViewFleet(fleet, true);
-        } else {
-          fleet_bar->RequestSelect(ship_select_request);
-        }
-
-        last_ship_select_request = ship_select_request;
-        select_clock             = select_now;
-        return;
-      }
-    }
-  }
-
-  if (Key::Pressed(KeyCode::Escape) && (Key::IsInputFocused() || Hub::IsInChat())) {
-    // This fixes issues with detecting when an input is selected
-    // As the game usually doesn't clear this when using Escape, only when
-    // pressing the back button with the mouse...
-    return Key::ClearInputFocus();
-  }
-
-  if (!is_in_chat) {
-    if (!Key::IsInputFocused()) {
-      if (MapKey::IsDown(GameFunction::SelectCurrent)) {
-        auto fleet_bar = ObjectFinder<FleetBarViewController>::Get();
-        if (fleet_bar) {
-          auto fleet_controller = fleet_bar->fleetPanelController();
-          auto fleet            = fleet_controller ? fleet_controller->fleet() : nullptr;
-          if (fleet) {
-            if (NavigationSectionManager::Instance() && NavigationSectionManager::Instance()->SNavigationManager()) {
-              NavigationSectionManager::Instance()->SNavigationManager()->HideInteraction();
-            }
-            FleetsManager::Instance()->RequestViewFleet(fleet, true);
-            return;
-          }
-        }
-      }
-
-      if ((MapKey::IsDown(GameFunction::ToggleQueue))) {
-        config->queue_enabled = !config->queue_enabled;
-        // Forget stale recovery authorizations; existing native target queues keep processing.
-        ResetQueueRecoveryTracking();
-        return;
-      }
-
-      if ((MapKey::IsDown(GameFunction::ShowChat) || MapKey::IsDown(GameFunction::ShowChatSide1)
-           || MapKey::IsDown(GameFunction::ShowChatSide2))) {
-        if (auto chat_manager = ChatManager::Instance(); chat_manager) {
-          if (chat_manager->IsSideChatOpen()) {
-            if (auto view_controller = ObjectFinder<FullScreenChatViewController>::Get(); view_controller) {
-              if (auto message_list = view_controller->messageList(); message_list) {
-                if (auto message_field = message_list->inputField(); message_field) {
-                  message_field->ActivateInputField();
-                }
-              }
-            }
-          } else if (MapKey::IsDown(GameFunction::ShowChatSide1) || MapKey::IsDown(GameFunction::ShowChatSide2)) {
-            chat_manager->OpenChannel(ChatChannelCategory::Alliance, ChatViewMode::Side);
-          } else {
-            chat_manager->OpenChannel(ChatChannelCategory::Alliance, ChatViewMode::Fullscreen);
-          }
-        }
-      }
-
-      if (MapKey::IsDown(GameFunction::MoveLeft)) {
-        auto const result = MoveDockInManagementView(true) || MoveShipSelectionInDock(true) || MoveArtifactCanvas(true)
-                            || MoveOfficerCanvas(true);
-        if (result) {
-          return;
-        }
-      }
-
-      if (MapKey::IsDown(GameFunction::MoveRight)) {
-        auto const result = MoveDockInManagementView(false) || MoveShipSelectionInDock(false)
-                            || MoveArtifactCanvas(false) || MoveOfficerCanvas(false);
-        if (result) {
-          return;
-        }
-      }
-
-      if (Config::Get().focus_search && MapKey::IsDown(GameFunction::FocusSearch)) {
-        if (FocusSearchBox()) {
-          return;
-        }
-      }
-
-      if (MapKey::IsDown(GameFunction::ShowQTrials)) {
-        return GotoSection(SectionID::ChallengeSelection);
-      } else if (MapKey::IsDown(GameFunction::ShowBookmarks)) {
-        auto bookmark_manager = BookmarksManager::Instance();
-        if (bookmark_manager) {
-          return bookmark_manager->ViewBookmarks();
-        }
-        return GotoSection(SectionID::Bookmarks_Main);
-      } else if (MapKey::IsDown(GameFunction::ShowLookup)) {
-        auto bookmark_manager = BookmarksManager::Instance();
-        if (bookmark_manager) {
-          bookmark_manager->ViewCoordinateSearch();
-          return;
-        }
-        spdlog::warn("[ShowLookup] BookmarksManager instance not available, falling back to main bookmarks");
-        GotoSection(SectionID::Bookmarks_Main);
-        return;
-      } else if (MapKey::IsDown(GameFunction::ShowRefinery)) {
-        return GotoSection(SectionID::Shop_Refining_List);
-      } else if (MapKey::IsDown(GameFunction::ShowFactions)) {
-        return GotoSection(SectionID::Shop_MainFactions);
-      } else if (MapKey::IsDown(GameFunction::ShoWStationExterior)) {
-        return GotoSection(SectionID::Starbase_Exterior);
-      } else if (MapKey::IsDown(GameFunction::NativeShortcutGalaxy)) {
-        InvokeNativeShortcut<"OnGalaxyAction">("Galaxy");
-        return;
-      } else if (MapKey::IsDown(GameFunction::ShowGalaxy)) {
-        return ChangeNavigationSection(SectionID::Navigation_Galaxy);
-      } else if (MapKey::IsDown(GameFunction::ShowStationInterior)) {
-        return GotoSection(SectionID::Starbase_Interior);
-      } else if (MapKey::IsDown(GameFunction::ShowHaven)) {
-        return PlanetaryBaseManager::ViewOwnHaven();
-      } else if (MapKey::IsDown(GameFunction::ShowSystem)) {
-        return ChangeNavigationSection(SectionID::Navigation_System);
-      } else if (MapKey::IsDown(GameFunction::ShowArtifacts)) {
-        return GotoSection(SectionID::ArtifactHall_Inventory);
-      } else if (MapKey::IsDown(GameFunction::ShowShipConstruction)) {
-        InvokeNativeShortcut<"OnShipsAction">("Ship Construction");
-        return;
-      } else if (MapKey::IsDown(GameFunction::ShowOfficerSwap)) {
-        auto* section_manager = Hub::get_SectionManager();
-        spdlog::info("[OfficerSwap] shortcut pressed current_section={}",
-                     section_manager ? static_cast<int32_t>(section_manager->CurrentSection()) : 0);
-        if (PressOfficerSwapButton()) {
-          return;
-        }
-
-        auto* fleet_bar        = ObjectFinder<FleetBarViewController>::Get();
-        auto* fleet_controller = fleet_bar ? fleet_bar->fleetPanelController() : nullptr;
-        auto* fleet            = fleet_controller ? fleet_controller->fleet() : nullptr;
-        if (fleet) {
-          spdlog::info("[OfficerSwap] requesting Manage Ships before officer assignment fleet={}",
-                       static_cast<void*>(fleet));
-          fleet_controller->RequestAction(fleet, ActionType::Manage, 0, ActionBehaviour::Default);
-          show_officer_swap_pending = 300;
-        } else {
-          spdlog::warn("[Hotkeys] unable to open Manage Ships for Officer Swap");
-        }
-        return;
-      } else if (MapKey::IsDown(GameFunction::ShowShipSwap)) {
-        auto* section_manager = Hub::get_SectionManager();
-        spdlog::info("[ShipSwap] shortcut pressed current_section={}",
-                     section_manager ? static_cast<int32_t>(section_manager->CurrentSection()) : 0);
-        if (PressShipSwapButton()) {
-          return;
-        }
-
-        auto* fleet_bar        = ObjectFinder<FleetBarViewController>::Get();
-        auto* fleet_controller = fleet_bar ? fleet_bar->fleetPanelController() : nullptr;
-        auto* fleet            = fleet_controller ? fleet_controller->fleet() : nullptr;
-        if (fleet) {
-          spdlog::info("[ShipSwap] requesting Manage Ships before swap fleet={}", static_cast<void*>(fleet));
-          fleet_controller->RequestAction(fleet, ActionType::Manage, 0, ActionBehaviour::Default);
-          show_ship_swap_pending = 300;
-        } else {
-          spdlog::warn("[Hotkeys] unable to open Manage Ships for Ship Swap");
-        }
-        return;
-      } else if (MapKey::IsDown(GameFunction::ShowShields)) {
-        InvokeNativeShortcut<"OnPeaceShieldAction">("Peace Shields");
-        return;
-      } else if (MapKey::IsDown(GameFunction::ShowBattlelogs)) {
-        InvokeNativeShortcut<"OnInboxAction">("Battle Reports");
-        return;
-      } else if (MapKey::IsDown(GameFunction::ShowInventory)) {
-        return GotoSection(SectionID::InventoryList);
-      } else if (MapKey::IsDown(GameFunction::ShowMissions)) {
-        return GotoSection(SectionID::Missions_AcceptedList);
-      } else if (MapKey::IsDown(GameFunction::ShowResearch)) {
-        return GotoSection(SectionID::Research_LandingPage);
-      } else if (MapKey::IsDown(GameFunction::ShowScrapYard)) {
-        return GotoSection(SectionID::ShipScrapping_List);
-      } else if (MapKey::IsDown(GameFunction::ShowOfficers)) {
-        return GotoSection(SectionID::OfficerInventory);
-      } else if (MapKey::IsDown(GameFunction::ShowOfficerPresets)) {
-        if (PressOfficerPresetsButton()) {
-          return;
-        }
-
-        officer_presets_assignment_opened = PressOfficerSwapButton();
-        if (!officer_presets_assignment_opened) {
-          auto* fleet_bar        = ObjectFinder<FleetBarViewController>::Get();
-          auto* fleet_controller = fleet_bar ? fleet_bar->fleetPanelController() : nullptr;
-          auto* fleet            = fleet_controller ? fleet_controller->fleet() : nullptr;
-          if (fleet) {
-            spdlog::info("[OfficerPresets] requesting Manage Ships before officer presets fleet={}",
-                         static_cast<void*>(fleet));
-            fleet_controller->RequestAction(fleet, ActionType::Manage, 0, ActionBehaviour::Default);
-          } else {
-            spdlog::warn("[Hotkeys] unable to open Manage Ships for Officer Presets");
-            return;
-          }
-        }
-        show_officer_presets_pending = 300;
-        return;
-      } else if (MapKey::IsDown(GameFunction::ShowCommander)) {
-        // TODO: Does not work properly, defaults to first FleetCommander (spock, rather than selected fleet
-        // commander)
-        return GotoSection(SectionID::FleetCommander_Management);
-      } else if (MapKey::IsDown(GameFunction::ShowAwayTeam)) {
-        return GotoSection(SectionID::Missions_AwayTeamsList);
-      } else if (MapKey::IsDown(GameFunction::NativeShortcutEvents)) {
-        InvokeNativeShortcut<"OnEventsAction">("Events");
-        return;
-      } else if (MapKey::IsDown(GameFunction::ShowEvents)) {
-        return GotoSection(SectionID::Tournament_Group_Selection);
-      } else if (MapKey::IsDown(GameFunction::ShowExoComp)) {
-        return GotoSection(SectionID::Consumables);
-      } else if (MapKey::IsDown(GameFunction::ShowDaily)) {
-        return GotoSection(SectionID::Missions_DailyGoals);
-      } else if (MapKey::IsDown(GameFunction::ShowGifts)) {
-        return GotoSection(SectionID::Shop_List);
-      } else if (MapKey::IsDown(GameFunction::ShowAlliance)) {
-        return GotoSection(SectionID::Alliance_Main);
-      } else if (MapKey::IsDown(GameFunction::ShowAllianceHelp)) {
-        return GotoSection(SectionID::Alliance_Help);
-      } else if (MapKey::IsDown(GameFunction::ShowAllianceArmada)) {
-        return GotoSection(SectionID::Alliance_Armadas);
-      } else if (MapKey::IsDown(GameFunction::ShowSettings)) {
-        return GotoSection(SectionID::GameSettings);
-      } else if (MapKey::IsPressed(GameFunction::UiScaleUp)) {
-        config->AdjustUiScale(true);
-      } else if (MapKey::IsPressed(GameFunction::UiScaleDown)) {
-        config->AdjustUiScale(false);
-      } else if (MapKey::IsPressed(GameFunction::UiShipScaleUp)) {
-        config->AdjustUiShipScale(true);
-      } else if (MapKey::IsPressed(GameFunction::UiShipScaleDown)) {
-        config->AdjustUiShipScale(false);
-      } else if (MapKey::IsPressed(GameFunction::UiViewerScaleUp)) {
-        config->AdjustUiViewerScale(true);
-      } else if (MapKey::IsPressed(GameFunction::UiViewerScaleDown)) {
-        config->AdjustUiViewerScale(false);
-      } else if (MapKey::IsDown(GameFunction::ToggleAutoConfirmInstantWarp)) {
-        CycleAutoConfirmInstantWarp(*config);
-      } else if (MapKey::IsDown(GameFunction::TogglePreviewLocate)) {
-        config->disable_preview_locate = !config->disable_preview_locate;
-      } else if (MapKey::IsDown(GameFunction::TogglePreviewRecall)) {
-        config->disable_preview_recall = !config->disable_preview_recall;
-      } else if (MapKey::IsDown(GameFunction::ToggleCargoDefault)) {
-        config->show_cargo_default = !config->show_cargo_default;
-      } else if (MapKey::IsDown(GameFunction::ToggleCargoPlayer)) {
-        config->show_player_cargo = !config->show_player_cargo;
-      } else if (MapKey::IsDown(GameFunction::ToggleCargoStation)) {
-        config->show_station_cargo = !config->show_station_cargo;
-      } else if (MapKey::IsDown(GameFunction::ToggleCargoHostile)) {
-        config->show_hostile_cargo = !config->show_hostile_cargo;
-      } else if (MapKey::IsDown(GameFunction::ToggleCargoArmada)) {
-        config->show_armada_cargo = !config->show_armada_cargo;
-      } else if (MapKey::IsDown(GameFunction::LogLevelOff)) {
-        // spdlog::log("Setting log level to OFF");
-        spdlog::set_level(spdlog::level::off);
-        spdlog::flush_on(spdlog::level::off);
-      } else if (MapKey::IsDown(GameFunction::LogLevelError)) {
-        spdlog::set_level(spdlog::level::err);
-        spdlog::flush_on(spdlog::level::err);
-        // spdlog::log("Setting log level to ERROR");
-      } else if (MapKey::IsDown(GameFunction::LogLevelWarn)) {
-        spdlog::set_level(spdlog::level::warn);
-        spdlog::flush_on(spdlog::level::warn);
-        // spdlog::log("Setting log level to WARN");
-      } else if (MapKey::IsDown(GameFunction::LogLevelInfo)) {
-        spdlog::set_level(spdlog::level::info);
-        spdlog::flush_on(spdlog::level::info);
-        // spdlog::log("Setting log level to INFO");
-      } else if (MapKey::IsDown(GameFunction::LogLevelDebug)) {
-        spdlog::set_level(spdlog::level::debug);
-        spdlog::flush_on(spdlog::level::debug);
-        // spdlog::log("Setting log level to DEBUG");
-      } else if (MapKey::IsDown(GameFunction::LogLevelTrace)) {
-        spdlog::set_level(spdlog::level::trace);
-        spdlog::flush_on(spdlog::level::trace);
-        // spdlog::log("Setting log level to TRACE");
-      } else if (MapKey::IsDown(GameFunction::ShowShips)) {
-        auto fleet_bar        = ObjectFinder<FleetBarViewController>::Get();
-        auto fleet_controller = fleet_bar ? fleet_bar->fleetPanelController() : nullptr;
-        auto fleet            = fleet_controller ? fleet_controller->fleet() : nullptr;
-        if (fleet) {
-          fleet_controller->RequestAction(fleet, ActionType::Manage, 0, ActionBehaviour::Default);
-        }
-      }
-    }
-  } else {
-    if (auto chat_manager = ChatManager::Instance(); chat_manager) {
-      if (MapKey::IsDown(GameFunction::SelectChatGlobal)) {
-        return chat_manager->OpenChannel(ChatChannelCategory::Global);
-      } else if (MapKey::IsDown(GameFunction::SelectChatAlliance)) {
-        return chat_manager->OpenChannel(ChatChannelCategory::Alliance);
-      } else if (MapKey::IsDown(GameFunction::SelectChatPrivate)) {
-        return chat_manager->OpenChannel(ChatChannelCategory::Private);
-      }
-    }
-  }
-
-  if (!Key::IsInputFocused()) {
-    // Lets try to remove the pre-scan because we hit escape and it's visible
-    if (Key::Pressed(KeyCode::Escape)) {
-      if (config->primary_requires_visible_target) {
-        force_space_action_next_frame = false;
-      }
-      if (DidHideViewers()) {
-        return;
-      }
-    }
-
-    // Dismiss the golden rewards screen when escape or space is pressed.
-    if (MapKey::IsDown(GameFunction::ActionPrimary) || Key::Pressed(KeyCode::Escape)) {
-      if (auto reward_controller = ObjectFinder<AnimatedRewardsScreenViewController>::Get(); reward_controller) {
-        if (reward_controller->IsActive()) {
-          return reward_controller->GoBackToLastSection();
-        }
-      }
-    }
-
-    if (MapKey::IsDown(GameFunction::ActionPrimary) || MapKey::IsDown(GameFunction::ActionSecondary)
-        || MapKey::IsDown(GameFunction::ActionRecall) || MapKey::IsDown(GameFunction::ActionRepair)
-        || MapKey::IsDown(GameFunction::ActionQueue) || MapKey::IsDown(GameFunction::ActionQueueClear)
-        || force_space_action_next_frame) {
-      if (Hub::IsInSystemOrGalaxyOrStarbase() && !Hub::IsInChat() && !Key::IsInputFocused()) {
-        auto fleet_bar = ObjectFinder<FleetBarViewController>::Get();
-        bool was_forced = force_space_action_next_frame;
-        ExecuteSpaceAction(fleet_bar);
-        if (was_forced) {
-          force_space_action_next_frame = false;
-        }
-      }
-    }
-
-    DailyFactionBulkClaimUpdate();
-
-    if (MapKey::IsDown(GameFunction::ActionView)) {
-      auto all_pre_scan_widgets = ObjectFinder<PreScanTargetWidget>::GetAll();
-
-      for (auto& pre_scan_widget : all_pre_scan_widgets) {
-        auto visibility_controller = pre_scan_widget ? pre_scan_widget->visibilityController() : nullptr;
-        auto rewardsWidget         = pre_scan_widget ? pre_scan_widget->rewardsButtonWidget() : nullptr;
-        auto rewards_controller    = rewardsWidget ? rewardsWidget->rewardsController() : nullptr;
-        if (visibility_controller
-            && (visibility_controller->state() == VisibilityState::Visible
-                || visibility_controller->state() == VisibilityState::Show)
-            && rewards_controller) {
-          if (rewards_controller->state() != VisibilityState::Visible
-              && rewards_controller->state() != VisibilityState::Show) {
-            show_info_pending = 5;
-          } else {
-            rewards_controller->Hide();
-          }
-        }
-      }
-    }
-
-    // Did we not find a rewards widget in the previous frame?
-    if (show_info_pending > 0) {
-      auto all_pre_scan_widgets = ObjectFinder<PreScanTargetWidget>::GetAll();
-
-      for (auto& pre_scan_widget : all_pre_scan_widgets) {
-        auto       visibility_controller = pre_scan_widget ? pre_scan_widget->visibilityController() : nullptr;
-        auto       rewardsWidget         = pre_scan_widget ? pre_scan_widget->rewardsButtonWidget() : nullptr;
-        auto       rewards_controller    = rewardsWidget ? rewardsWidget->rewardsController() : nullptr;
-        const auto pre_scan_visible      = visibility_controller
-                                           && (visibility_controller->state() == VisibilityState::Visible
-                                               || visibility_controller->state() == VisibilityState::Show);
-        if (pre_scan_visible && rewards_controller) {
-          const auto rewards_widget_visible = rewards_controller->state() == VisibilityState::Visible
-                                              || rewards_controller->state() == VisibilityState::Show;
-          if (!rewards_widget_visible) {
-            rewards_controller->Show(true);
-          }
-        }
-      }
-      show_info_pending -= 1;
-    }
-  }
-
-  if (config->disable_escape_exit && Key::Pressed(KeyCode::Escape)) {
-    // Keep suppressing a held key. Only distinct key-down edges participate in
-    // the double-tap window.
-    if (config->disable_escape_exit_timer <= 0 || !Key::Down(KeyCode::Escape)) {
-      return;
-    }
-
-    static auto previous_escape_down = std::chrono::steady_clock::time_point{};
-    const auto  escape_now           = std::chrono::steady_clock::now();
-    const auto  escape_diff =
-        std::chrono::duration_cast<std::chrono::milliseconds>(escape_now - previous_escape_down);
-
-    if (previous_escape_down == std::chrono::steady_clock::time_point{}
-        || escape_diff > std::chrono::milliseconds(config->disable_escape_exit_timer)) {
-      previous_escape_down = escape_now;
-      return;
-    }
-
-    // Consume the completed pair so a rapid third press starts a new one.
-    previous_escape_down = {};
   }
 
-  // config->Load();
-
-  return original(_this);
-}
+  if (SelectShipShortcuts())
+    return true;
 
-template <typename T> inline bool CanHideViewer(T* widget, bool require_parent = false)
-{
-  auto* visibility = widget ? widget->visibilityController() : nullptr;
-  if (!visibility || (visibility->state() != VisibilityState::Visible && visibility->state() != VisibilityState::Show)) {
-    return false;
-  }
-  if (!require_parent) {
+  // The game only clears a focused text field from its back button; Escape should too.
+  const bool in_chat = Hub::IsInChat();
+  if (unity::Key::Pressed(unity::KeyCode::Escape) && (typing || in_chat)) {
+    unity::Key::ClearInputFocus();
     return true;
   }
-  auto* parent = widget->Parent();
-  return parent && parent->IsShowing();
-}
 
-template <typename T> inline bool CanHideViewersOfType()
-{
-  for (auto widget : ObjectFinder<T>::GetAll()) {
-    if (CanHideViewer(widget)) {
+  if (in_chat) {
+    if (ChatChannelShortcuts())
       return true;
-    }
-  }
-
-  return false;
-}
-
-bool CanHideViewers()
-{
-  return (CanHideViewersOfType<AllianceStarbaseObjectViewerWidget>() || CanHideViewersOfType<ArmadaObjectViewerWidget>()
-          || CanHideViewersOfType<CelestialObjectViewerWidget>() || CanHideViewersOfType<EmbassyObjectViewer>()
-          || CanHideViewersOfType<HousingObjectViewerWidget>() || CanHideViewersOfType<MiningObjectViewerWidget>()
-          || CanHideViewersOfType<MissionsObjectViewerWidget>() || CanHideViewersOfType<PreScanTargetWidget>()
-          || CanHideViewersOfType<HousingObjectViewerWidget>());
-}
-
-template <typename T> inline bool DidHideViewersOfType()
-{
-  const auto objects = ObjectFinder<T>::GetAll();
-  auto       didHide = false;
-  for (auto widget : objects) {
-    if (CanHideViewer(widget)) {
-      widget->HideAllViewers();
-      didHide = true;
-    }
-  }
-
-  return didHide;
-}
-
-bool DidHideViewers()
-{
-  return DidHideViewersOfType<AllianceStarbaseObjectViewerWidget>() || DidHideViewersOfType<ArmadaObjectViewerWidget>()
-         || DidHideViewersOfType<CelestialObjectViewerWidget>() || DidHideViewersOfType<EmbassyObjectViewer>()
-         || DidHideViewersOfType<HousingObjectViewerWidget>() || DidHideViewersOfType<MiningObjectViewerWidget>()
-         || DidHideViewersOfType<MissionsObjectViewerWidget>() || DidHideViewersOfType<PreScanTargetWidget>()
-         || DidHideViewersOfType<HousingObjectViewerWidget>();
-}
-
-void GotoSection(SectionID sectionID, void* section_data)
-{
-  Hub::get_SectionManager()->TriggerSectionChange(sectionID, section_data, false, false, true);
-}
-
-void ChangeNavigationSection(SectionID sectionID)
-{
-  const auto section_data = Hub::get_SectionManager()->sectionStorage()->GetState(sectionID);
-
-  if (section_data) {
-    GotoSection(sectionID, section_data);
-  } else {
-    NavigationSectionManager::ChangeNavigationSection(sectionID);
-  }
-}
-
-#define FleetAction_Format "Fleet {} ({}) #{} - State: {}, previous {} - canAction {}, canState {} - didAction: {}"
-
-template <typename T>
-inline bool DidExecuteFleetAction(std::string_view actionText, ActionType actionType, FleetBarViewController* fleet_bar,
-                                  const std::span<const FleetState> wantedStates,
-                                  FleetState                        helpState = FleetState::Unknown)
-{
-  if (!fleet_bar) {
-    return false;
-  }
-
-  auto fleet_controller = fleet_bar->fleetPanelController();
-  auto fleet            = fleet_controller ? fleet_controller->fleet() : nullptr;
-  if (!fleet) {
-    return false;
-  }
-  auto fleet_state = fleet->CurrentState();
-
-  auto       fleet_id   = fleet->Id();
-  auto       prev_state = fleet->PreviousState();
-  auto       canAction  = true; // actionRequired->CheckIsMet();
-  FleetState canState   = FleetState::Unknown;
-  auto       didAction  = false;
-
-  if (std::find(std::begin(wantedStates), std::end(wantedStates), fleet_state) != std::end(wantedStates)) {
-    canState = fleet_state;
-  }
-
-  spdlog::trace(FleetAction_Format, actionText, actionType.flagValue, (int)fleet_id, (int)fleet_state, (int)prev_state,
-                canAction, (int)canState, "[start]");
-
-  if (canState != FleetState::Unknown && canAction) {
-    if (NavigationSectionManager::Instance() && NavigationSectionManager::Instance()->SNavigationManager()) {
-      NavigationSectionManager::Instance()->SNavigationManager()->HideInteraction();
-    }
-
-    didAction = fleet_controller->RequestAction(fleet, actionType, 0, ActionBehaviour::Default);
-  }
-
-  if (helpState != FleetState::Unknown && (didAction || helpState == fleet->CurrentState())) {
-    didAction = didAction || fleet_controller->RequestAction(fleet, actionType, 0, ActionBehaviour::AskHelp);
-  }
-
-  spdlog::trace(FleetAction_Format, actionText, actionType.flagValue, (int)fleet_id, (int)fleet_state, (int)prev_state,
-                canAction, (int)canState, didAction);
-
-  return didAction;
-}
-
-bool DidExecuteRecall(FleetBarViewController* fleet_bar)
-{
-  static constexpr FleetState states[] = {FleetState::IdleInSpace, FleetState::Impulsing, FleetState::Mining,
-                                          FleetState::Capturing};
-
-  auto fleet_controller = fleet_bar->fleetPanelController();
-
-  return DidExecuteFleetAction<RecallRequirement>("Recall", ActionType::Recall, fleet_bar, states);
-}
-
-bool DidExecuteRepair(FleetBarViewController* fleet_bar)
-{
-  static constexpr FleetState states[] = {FleetState::Docked, FleetState::Destroyed};
-
-  return DidExecuteFleetAction<CanRepairRequirement>("Repair", ActionType::Repair, fleet_bar, states,
-                                                     FleetState::Repairing);
-}
-
-void ExecuteSpaceAction(FleetBarViewController* fleet_bar)
-{
-  if (MapKey::IsDown(GameFunction::ActionPrimary)) {
-    if (auto* navigation = ObjectFinder<NavigationInteractionUIViewController>::Get();
-        navigation && navigation->TryPressJoinWaveDefense()) {
-      return;
-    }
-    // Query active viewers without adding constructor detours for this popup or its subclasses.
-    if (auto* viewers = WaveDefenseObjectViewerWidget::FindActiveViewers()) {
-      for (auto* widget : *viewers) {
-        if (CanHideViewer(widget, true)) {
-          // Use the displayed native action, including its eligibility and confirmation checks.
-          widget->PressPrimaryButton();
-          return;
-        }
-      }
-    }
-  }
-
-  if (!fleet_bar) {
-    return;
-  }
-
-  auto fleet_controller = fleet_bar->fleetPanelController();
-  auto fleet            = fleet_controller ? fleet_controller->fleet() : nullptr;
-  if (!fleet) {
-    return;
-  }
-
-  auto action_queue = ActionQueueManager::Instance();
-  if (!action_queue) {
-    return;
-  }
-
-  auto has_primary       = MapKey::IsDown(GameFunction::ActionPrimary) || force_space_action_next_frame;
-  auto has_repair        = MapKey::IsDown(GameFunction::ActionRepair);
-  auto has_recall_cancel = MapKey::IsDown(GameFunction::ActionRecallCancel);
-  auto has_secondary     = MapKey::IsDown(GameFunction::ActionSecondary);
-  auto has_queue         = MapKey::IsDown(GameFunction::ActionQueue);
-  auto has_queue_clear   = MapKey::IsDown(GameFunction::ActionQueueClear);
-  auto has_recall =
-      MapKey::IsDown(GameFunction::ActionRecall) && (!Config::Get().disable_preview_recall || !CanHideViewers());
-  const bool require_visible_target = has_primary && Config::Get().primary_requires_visible_target;
-
-  if (has_queue_clear) {
-    action_queue->ClearQueue(fleet);
-  } else if (has_recall_cancel
-             && (fleet->CurrentState() == FleetState::WarpCharging || fleet->CurrentState() == FleetState::Warping)) {
-    fleet_controller->CancelButtonClicked();
-  } else {
-    auto all_pre_scan_widgets = ObjectFinder<PreScanTargetWidget>::GetAll();
-    for (auto pre_scan_widget : all_pre_scan_widgets) {
-      if (CanHideViewer(pre_scan_widget, require_visible_target)) {
-
-        if (auto mine_object_viewer_widget = ObjectFinder<MiningObjectViewerWidget>::Get();
-            CanHideViewer(mine_object_viewer_widget, require_visible_target)) {
-          if (has_secondary && pre_scan_widget->scanEngageButtonsWidget()) {
-            return pre_scan_widget->scanEngageButtonsWidget()->OnScanButtonClicked();
-          } else if (has_primary) {
-            return mine_object_viewer_widget->MineClicked();
-          }
-        }
-
-        if (has_queue && action_queue->IsQueueUnlocked() && pre_scan_widget->addToQueueButtonWidget()
-            && pre_scan_widget->scanEngageButtonsWidget()) {
-          auto context = pre_scan_widget->scanEngageButtonsWidget()->Context();
-          auto type    = GetHullTypeFromBattleTarget(context);
-
-          if (type != HullType::ArmadaTarget && (type != HullType::Any || force_space_action_next_frame)) {
-            if (pre_scan_widget->addToQueueButtonWidget()->isActiveAndEnabled()) {
-              auto listener = pre_scan_widget->addToQueueButtonWidget()->SemaphoreListener();
-              if (listener && !action_queue->IsQueueFull(fleet)) {
-                auto button = listener->TheButton();
-                if (button) {
-                  button->Press();
-                  DidHideViewers();
-                }
-              }
-              return;
-            }
-
-            if (type == HullType::Any) {
-              force_space_action_next_frame = true;
-              return;
-            }
-          }
-        }
-
-        if (has_secondary && pre_scan_widget->scanEngageButtonsWidget()) {
-          return pre_scan_widget->scanEngageButtonsWidget()->OnScanButtonClicked();
-        }
-
-        if (has_primary && pre_scan_widget->scanEngageButtonsWidget()
-            && pre_scan_widget->scanEngageButtonsWidget()->enabled()) {
-          auto context = pre_scan_widget->scanEngageButtonsWidget()->Context();
-          auto type    = GetHullTypeFromBattleTarget(context);
-
-          // Try once more in X frames if we get ANY
-          // in-case of failed to navgitate error?
-          auto armada_widget = ObjectFinder<ArmadaObjectViewerWidget>::Get();
-          auto armada_state  = VisibilityState::Unknown;
-
-          if (armada_widget) {
-            if (armada_widget->visibilityController()) {
-              armada_state = armada_widget->visibilityController()->State();
-            } else {
-              spdlog::warn("ArmadaWidget has no visibility controller, using default Visible state");
-              armada_state = VisibilityState::Visible;
-            }
-          }
-
-          auto canActionPrimary = type != HullType::Any;
-          if (type == HullType::ArmadaTarget
-              && (armada_state == VisibilityState::Visible || armada_state == VisibilityState::Show)) {
-            canActionPrimary = false;
-          } else if (force_space_action_next_frame) {
-            canActionPrimary = true;
-          }
-
-          // Try once more in X frames if we get ANY
-          // in-case of failed to navgitate error?
-          if (canActionPrimary) {
-            if (type == HullType::ArmadaTarget) {
-              auto* attack_button = pre_scan_widget->armadaAttackButton();
-              if (attack_button && attack_button->isActiveAndEnabled()) {
-                auto listener = attack_button->SemaphoreListener();
-                if (listener) {
-                  auto button = listener->TheButton();
-                  if (button) {
-                    button->Press();
-                  }
-                }
-                return;
-              }
-              pre_scan_widget->scanEngageButtonsWidget()->OnArmadaButtonClicked();
-            } else {
-              pre_scan_widget->scanEngageButtonsWidget()->OnEngageButtonClicked();
-            }
-            return;
-          } else if (type == HullType::Any) {
-            force_space_action_next_frame = true;
-            return;
-          }
-        }
-      }
-    }
-
-    if (auto mine_object_viewer_widget = ObjectFinder<MiningObjectViewerWidget>::Get();
-        CanHideViewer(mine_object_viewer_widget, require_visible_target)) {
-      if (has_secondary && mine_object_viewer_widget->scanEngageButtonsWidget()) {
-        if (mine_object_viewer_widget->scanEngageButtonsWidget()->Context()) {
-          return mine_object_viewer_widget->scanEngageButtonsWidget()->OnScanButtonClicked();
-        }
-      } else if (has_primary) {
-        return mine_object_viewer_widget->MineClicked();
-      }
-    } else if (auto star_node_object_viewer_widget = ObjectFinder<StarNodeObjectViewerWidget>::Get();
-               star_node_object_viewer_widget && star_node_object_viewer_widget->Context()
-               && (!require_visible_target || CanHideViewer(star_node_object_viewer_widget, true))) {
-      if (has_secondary) {
-        star_node_object_viewer_widget->OnViewButtonActivation();
-        return;
-      } else if (has_primary) {
-        star_node_object_viewer_widget->InitiateWarp();
-        return;
-      }
-    } else if (auto navigation_ui_controller = ObjectFinder<NavigationInteractionUIViewController>::Get();
-               navigation_ui_controller && has_primary) {
-      auto armada_widget = ObjectFinder<ArmadaObjectViewerWidget>::Get();
-      auto armada_state  = VisibilityState::Unknown;
-
-      if (armada_widget) {
-        if (armada_widget->visibilityController()) {
-          armada_state = armada_widget->visibilityController()->State();
-        } else {
-          spdlog::warn("ArmadaWidget has no visibility controller, using default Visible state");
-          armada_state = VisibilityState::Visible;
-        }
-      }
-
-      spdlog::info("have armada? {}, State {}", (armada_widget ? "Yes" : "No"), (int)armada_state);
-      if (armada_widget && (armada_state == VisibilityState::Visible || armada_state == VisibilityState::Show)) {
-        auto button = armada_widget->joinContext();
-        if (button && button->Interactable()) {
-          armada_widget->ValidateThenJoinArmada();
-          return;
-        }
-      } else {
-        // Dismissal keeps the native context's last position/path. Preserve that legacy shortcut unless opted out.
-        if (!require_visible_target || navigation_ui_controller->IsSetCourseVisible()) {
-          navigation_ui_controller->OnSetCourseButtonClick();
-        }
-        return;
-      }
-    }
-
-    if (has_recall && DidExecuteRecall(fleet_bar)) {
-      force_space_action_next_frame = false;
-      return;
-    }
-    if (has_repair && DidExecuteRepair(fleet_bar)) {
-      force_space_action_next_frame = false;
-      return;
-    }
-  }
-}
-
-HullType GetHullTypeFromBattleTarget(BattleTargetData* context)
-{
-  if (!context) {
-    return HullType::Any;
-  }
-  auto deployed_data = context->TargetFleetDeployedData();
-  if (!deployed_data) {
-    return HullType::Any;
-  }
-  auto hull_spec = deployed_data->Hull();
-  if (!hull_spec) {
-    return HullType::Any;
-  }
-  return hull_spec->Type();
-}
-
-void ChatMessageListLocalViewController_AboutToShow_Hook(ChatMessageListLocalViewController* _this);
-decltype(ChatMessageListLocalViewController_AboutToShow_Hook)* oChatMessageListLocalViewController_AboutToShow =
-    nullptr;
-void ChatMessageListLocalViewController_AboutToShow_Hook(ChatMessageListLocalViewController* _this)
-{
-  oChatMessageListLocalViewController_AboutToShow(_this);
-  if (_this->inputField()) {
-    _this->inputField()->SendOnFocus();
-  }
-}
-
-void InitializeActions_Hook(auto original, ShortcutsManager* _this)
-{
-  if (Config::Get().use_scopely_hotkeys) {
-    return original(_this);
-  }
-}
-
-bool CheckShowCargo(RewardsButtonWidget* widget)
-{
-  if (!widget || !Config::Get().show_cargo_default) {
-    return false;
-  }
-
-  if (!widget->Context()) {
-    return false;
-  }
-
-  const auto target_fleet_deployed = widget->Context()->TargetFleetDeployedData();
-
-  if (!target_fleet_deployed) {
-    return Config::Get().show_station_cargo;
-  }
-  auto fleet_type = target_fleet_deployed->FleetType();
-  if (fleet_type == DeployedFleetType::Player) {
-    return Config::Get().show_player_cargo;
-  } else if (fleet_type == DeployedFleetType::Marauder) {
-    if (auto hull = target_fleet_deployed->Hull(); hull && hull->Type() == HullType::ArmadaTarget) {
-      return Config::Get().show_armada_cargo;
-    } else {
-      return Config::Get().show_hostile_cargo;
-    }
-  }
-
-  return false;
-}
-
-void OnDidBindContext_Hook(auto original, RewardsButtonWidget* _this)
-{
-  if (!_this) {
-    return original(_this);
-  }
-
-  auto rewards_controller = _this->rewardsController();
-  auto pre_state          = rewards_controller ? rewards_controller->state() : VisibilityState::Unknown;
-  pre_state               = pre_state;
-  original(_this);
-
-  rewards_controller = _this->rewardsController();
-  auto post_state    = rewards_controller ? rewards_controller->state() : VisibilityState::Unknown;
-  post_state         = post_state;
-  if (rewards_controller && CheckShowCargo(_this)) {
-    rewards_controller->Show(true);
-    show_info_pending = 1;
-  }
-}
-
-void ShowWithFleet_Hook(auto original, PreScanTargetWidget* _this, void* a1)
-{
-  original(_this, a1);
-  if (!_this) {
-    return;
+  } else if (!typing) {
+    if (FleetShortcuts())
+      return true;
+    OpenChatShortcut();
+    if (ScreenShortcuts())
+      return true;
+    SettingShortcuts();
   }
 
-  auto rewards_button_widget = _this->rewardsButtonWidget();
-  auto rewards_controller    = rewards_button_widget ? rewards_button_widget->rewardsController() : nullptr;
-  if (rewards_controller && CheckShowCargo(rewards_button_widget)) {
-    rewards_controller->Show(true);
-    show_info_pending = 1;
-  }
+  return FleetActionShortcuts() || SwallowEscape();
 }
 
-bool install_screen_manager_update_hook()
+// With Scopely hotkeys off, the game never registers its own input actions, so its shortcuts cannot fire.
+void ShortcutsManager_InitializeActions_Hook(auto original, ShortcutsManager* _this)
 {
-  static bool installed = false;
-  if (installed) {
-    return true;
-  }
-
-  if (auto m = ScreenManager::Class::Method("Update")) {
-    if (!SPUD_STATIC_DETOUR(m.Pointer(), ScreenManager_Update_Hook))
-      return false;
-    installed = true;
-  }
-  return installed;
+  if (Config::Get().control.use_scopely_hotkeys)
+    original(_this);
 }
 
-void InstallShortcutHintHooks()
+void Install()
 {
-  // Configuration is fully parsed before hook installation. NONE, empty, and invalid bindings opt out.
-  if (!MapKey::HasBinding(GameFunction::ToggleShortcutHints)) {
-    return;
-  }
-
-  // Only the detour targets gate the feature. The managed members the hint path calls resolve on first use; a
-  // missing one is reported once and reads as null/false, which leaves the native hint text in place.
-  auto update_text       = ShortcutKeybindHint::Class::Method("UpdateText", 0);
-  auto update_visibility = ShortcutKeybindHint::Class::Method("UpdateVisibility", 1);
-  if (!initialize_actions_hook_ready || !update_text || !update_visibility) {
-    return;
-  }
-
-  MapKey::CacheShortcutHints();
-  original_shortcut_hint_update_text = SPUD_STATIC_DETOUR(update_text.Pointer(), ShortcutKeybindHint_UpdateText_Hook);
-  SPUD_STATIC_DETOUR(update_visibility.Pointer(), ShortcutKeybindHint_UpdateVisibility_Hook);
-  shortcut_hints_ready = true;
+  // The badges only make sense when the game's own input actions are under the mod's control.
+  if (IL2CPP_HOOK(ShortcutsManager::Class::Method("InitializeActions"), ShortcutsManager_InitializeActions_Hook))
+    InstallKeybindBadges();
+  InstallFleetActions();
+  hotkeys_installed = true;
 }
+} // namespace
 
-void InstallHotkeyHooks()
-{
-  if (auto m = ShortcutsManager::Class::Method("InitializeActions")) {
-    SPUD_STATIC_DETOUR(m.Pointer(), InitializeActions_Hook);
-    initialize_actions_hook_ready = true;
-  }
-
-  InstallShortcutHintHooks();
-
-  install_screen_manager_update_hook();
-#ifdef _MODDBG
-  fleet_watch::InstallRuntimeProbe();
-#endif
+bool HandleShortcuts()
+{ return hotkeys_installed && DispatchShortcuts(); }
 
-  if (auto m = RewardsButtonWidget::Class::Method("OnDidBindContext"))
-    SPUD_STATIC_DETOUR(m.Pointer(), OnDidBindContext_Hook);
-  if (auto m = PreScanTargetWidget::Class::Method("ShowWithFleet"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ShowWithFleet_Hook);
-}
+const Feature kHotkeys{"Hotkeys", &Config::Patches::hotkeyhooks, Install};
diff --git a/mods/src/patches/parts/instant_cargo.cc b/mods/src/patches/parts/instant_cargo.cc
deleted file mode 100644
index 491a591c7..000000000
--- a/mods/src/patches/parts/instant_cargo.cc
+++ /dev/null
@@ -1,91 +0,0 @@
-// Show actual cargo totals through the native text renderer, without its count-up animation.
-#include "config.h"
-#include "prime/TextLocalizer.h"
-
-#include <il2cpp/il2cpp.h>
-#include <spdlog/spdlog.h>
-#include <spud/detour.h>
-#if defined(_WIN32) && defined(_M_X64)
-namespace
-{
-using CargoProgressData = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "CargoProgressData">;
-
-// Fields below are declared on LegacyProgressBar and Widget`1; lookups walk the parents.
-struct LegacyComparableProgressBar : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Stats", "LegacyComparableProgressBar">;
-
-  TextLocalizer* currentValue_X_of_Y()
-  { return Field<"_currentValue_X_of_Y", TextLocalizer*>(); }
-  // IProgressData
-  il2cpp::Object* context()
-  { return Field<"m_context", il2cpp::Object*>(); }
-  bool snapToValue()
-  { return Field<"_snapToValue", bool>(); }
-  void SetSnapToValue(bool value)
-  { SetField<"_snapToValue">(value); }
-};
-
-bool IsCargoText(LegacyComparableProgressBar* self)
-{
-  auto*          label      = self->currentValue_X_of_Y();
-  auto*          identifier = label ? label->identifier() : nullptr;
-  constexpr char name[]     = "shared_x_of_y_x_coloured";
-  if (!identifier || il2cpp_string_length(identifier) != sizeof(name) - 1)
-    return false;
-  auto* chars = il2cpp_string_chars(identifier);
-  for (size_t i = 0; i < sizeof(name) - 1; ++i)
-    if (chars[i] != name[i])
-      return false;
-  auto* context = self->context();
-  if (!context || context->klass != CargoProgressData::Raw()) {
-    static bool reported{};
-    if (!reported) {
-      reported = true;
-      spdlog::warn("[InstantCargoText] cargo label has unexpected context {}; native text retained",
-                   context ? il2cpp_class_get_name(context->klass) : "null");
-    }
-    return false;
-  }
-  return true;
-}
-struct SnapScope {
-  LegacyComparableProgressBar* object;
-  bool                         previous;
-  explicit SnapScope(LegacyComparableProgressBar* self)
-      : object(self)
-      , previous(self->snapToValue())
-  { object->SetSnapToValue(true); }
-  ~SnapScope()
-  { object->SetSnapToValue(previous); }
-};
-void SetWidgetData_Hook(auto original, LegacyComparableProgressBar* self)
-{
-  if (!Config::Get().instant_cargo_counter || !self || !IsCargoText(self)) {
-    original(self);
-    return;
-  }
-  // Render the current model total using the game's own formatting/colour path.
-  // Restore the prefab flag before returning; reward updates and interpolation lifecycle continue normally.
-  SnapScope scope(self);
-  original(self);
-  static bool reported{};
-  if (!reported) {
-    reported = true;
-    spdlog::info("[InstantCargoText] matched cargo text; native snap active");
-  }
-}
-} // namespace
-#endif
-void InstallInstantCargoCounterHooks()
-{
-#if defined(_WIN32) && defined(_M_X64)
-  auto method = LegacyComparableProgressBar::Class::Method("SetWidgetData", 0);
-  // The lookup walks parents; only detour the bar's own override, never the shared Widget`1.SetWidgetData.
-  if (!method || method.Info()->klass != LegacyComparableProgressBar::Class::Raw())
-    return;
-  const bool installed = SPUD_STATIC_DETOUR(method.Pointer(), SetWidgetData_Hook) != nullptr;
-  spdlog::info("[InstantCargoText] native text hook {}", installed ? "installed" : "unavailable");
-#else
-  spdlog::info("[InstantCargoText] native text snap is not supported on this platform");
-#endif
-}
diff --git a/mods/src/patches/parts/instant_warp.cc b/mods/src/patches/parts/instant_warp.cc
new file mode 100644
index 000000000..4236755d3
--- /dev/null
+++ b/mods/src/patches/parts/instant_warp.cc
@@ -0,0 +1,203 @@
+// auto_confirm_instant_warp and the instant_warp_* ship filters: answers the warp-or-jump prompt for the ship,
+// previews that answer on the system card's visit button, and the shortcut that cycles the default.
+
+#include "config.h"
+#include "patches/patches.h"
+#include "str_utils.h"
+
+#include "prime/fleet.h"
+#include "prime/navigation.h"
+#include "prime/ui.h"
+#include "prime/viewers.h"
+
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
+#include <spdlog/spdlog.h>
+#include <unity/tracker.h>
+
+#include <algorithm>
+#include <chrono>
+
+namespace
+{
+// The action auto-confirm takes for `fleet`: always-ask wins, then auto-jump, then auto-warp, then the default.
+InstantWarpConfirmation ResolveConfirmation(FleetPlayerData* fleet)
+{
+  const auto& ui      = Config::Get().ui;
+  const auto  words   = fleet ? ShipNameWords(fleet->DisplayName()) : std::vector<std::string>();
+  const auto  matches = [&words](const ShipFilter& filter) {
+    return filter.all
+           || std::ranges::any_of(filter.names, [&](const auto& name) { return ShipNameMatches(words, name); });
+  };
+  if (matches(ui.instant_warp_always_ask))
+    return InstantWarpConfirmation::kNone;
+  if (matches(ui.instant_warp_auto_jump))
+    return InstantWarpConfirmation::kJump;
+  if (matches(ui.instant_warp_auto_warp))
+    return InstantWarpConfirmation::kWarp;
+  return ui.auto_confirm_instant_warp;
+}
+
+void CoursePromptPopupViewController_AboutToShow_Hook(auto original, CoursePromptPopupViewController* _this)
+{
+  original(_this);
+  auto* widget  = _this ? _this->PopupWidget() : nullptr;
+  auto* context = widget ? widget->Context() : nullptr;
+  if (!context || !context->HasInstantWarp())
+    return;
+
+  auto*      course = context->GetCourseData();
+  const auto action = ResolveConfirmation(course ? course->PlayerFleet() : nullptr);
+  spdlog::debug("InstantWarpConfirmation: resolved action {}", static_cast<int>(action));
+  switch (action) {
+    case InstantWarpConfirmation::kWarp:
+      widget->InitiateRegularWarp();
+      break;
+    case InstantWarpConfirmation::kJump:
+      widget->OnInstantWarpButtonClick();
+      break;
+    case InstantWarpConfirmation::kNone:
+      break;
+  }
+}
+
+// The system card's visit button reads WARP or JUMP when auto-confirm would pick one. This runs on the frame
+// tick rather than another UI detour, and only overrides the label text: never the button's context, timer,
+// resource cost, or click handler.
+bool label_installed = false;
+
+std::string CurrentText(TextLocalizer* label)
+{ return il2cpp::ToUtf8(label->CurrentText()); }
+
+// The label text this file set, so it is only cleared while it still reads that.
+struct OwnedLabel {
+  il2cpp::GcHandle handle;
+  std::string      text;
+
+  TextLocalizer* Get() const
+  { return handle.Get<TextLocalizer>(); }
+
+  void Clear()
+  {
+    auto* label    = Get();
+    auto  previous = std::move(text);
+    handle.Reset();
+    text.clear();
+    if (unity::Alive(label) && label->textOverride() && CurrentText(label) == previous)
+      label->ClearTextOverride();
+  }
+
+  void Apply(TextLocalizer* label, const char* desired)
+  {
+    if (!label || !desired) {
+      Clear();
+      return;
+    }
+    if (Get() != label) {
+      Clear();
+      // Don't take ownership from an existing text override.
+      if (label->textOverride())
+        return;
+      handle = il2cpp::GcHandle::Weak(label);
+      if (!handle)
+        return;
+    }
+    const auto current = CurrentText(label);
+    if (!text.empty() && label->textOverride() && current != text) {
+      Clear();
+      return;
+    }
+    if (text == desired && label->textOverride() && current == desired)
+      return;
+    label->OverrideLocalizedText(il2cpp::NewString(desired));
+    text = desired;
+  }
+};
+OwnedLabel action_label;
+
+void UpdateLabel()
+{
+  static auto next = std::chrono::steady_clock::time_point{};
+  const auto  now  = std::chrono::steady_clock::now();
+  if (now < next)
+    return;
+  next = now + std::chrono::milliseconds(100);
+
+  // Without a default or a jump/warp filter every prompt resolves to "ask"; skip the fleet lookups.
+  const auto& ui = Config::Get().ui;
+  if (ui.auto_confirm_instant_warp == InstantWarpConfirmation::kNone && !ui.instant_warp_auto_jump.all
+      && ui.instant_warp_auto_jump.names.empty() && !ui.instant_warp_auto_warp.all
+      && ui.instant_warp_auto_warp.names.empty()) {
+    action_label.Clear();
+    return;
+  }
+
+  auto*       widget  = unity::Newest<StarNodeObjectViewerWidget>();
+  const bool  active  = unity::Alive(widget) && widget->isActiveAndEnabled();
+  auto*       button  = active ? widget->visitButton() : nullptr;
+  const bool  enabled = unity::Alive(button) && button->isActiveAndEnabled() && button->Interactable();
+  const char* desired = nullptr;
+  // The ordinary visit path uses the currently selected fleet. The card's cached popup CourseData is only filled on
+  // click, so it cannot preview. Toll and wormhole buttons confirm their own way and keep the game's text.
+  if (enabled) {
+    auto* fleets     = FleetsManager::Instance();
+    auto* deployment = DeploymentManager::Instance();
+    auto* fleet      = unity::Alive(fleets) ? fleets->GetSelectedFleetData() : nullptr;
+    if (fleet && unity::Alive(deployment) && deployment->HasInstantWarpAbility(fleet)) {
+      switch (ResolveConfirmation(fleet)) {
+        case InstantWarpConfirmation::kWarp:
+          desired = "WARP";
+          break;
+        case InstantWarpConfirmation::kJump:
+          desired = "JUMP";
+          break;
+        case InstantWarpConfirmation::kNone:
+          break;
+      }
+    }
+  }
+  auto* label = desired ? button->mainText() : nullptr;
+  action_label.Apply(unity::Alive(label) ? label : nullptr, desired);
+}
+
+void InstantWarpUpdate()
+{
+  if (label_installed)
+    UpdateLabel();
+}
+
+void InstallInstantWarp()
+{
+  // The hook is useless without both popup actions, so skip it (and the label) when either has drifted.
+  const auto about_to_show = CoursePromptPopupViewController::Class::Method("AboutToShow", 0);
+  if (!about_to_show || !CoursePromptPopupWidget::Class::Method("InitiateRegularWarp", 0)
+      || !CoursePromptPopupWidget::Class::Method("OnInstantWarpButtonClick", 0)) {
+    return;
+  }
+
+  if (!IL2CPP_HOOK(about_to_show, CoursePromptPopupViewController_AboutToShow_Hook))
+    return;
+  label_installed = true;
+  spdlog::info("[WarpActionLabel] system-card action labels enabled");
+}
+} // namespace
+
+void CycleInstantWarpConfirmation()
+{
+  auto& setting = Config::Get().ui.auto_confirm_instant_warp;
+  switch (setting) {
+    case InstantWarpConfirmation::kNone:
+      setting = InstantWarpConfirmation::kWarp;
+      break;
+    case InstantWarpConfirmation::kWarp:
+      setting = InstantWarpConfirmation::kJump;
+      break;
+    case InstantWarpConfirmation::kJump:
+      setting = InstantWarpConfirmation::kNone;
+      break;
+  }
+  constexpr const char* kNames[] = {"none", "warp", "jump"};
+  spdlog::info("Auto-confirm instant warp set to {}", kNames[static_cast<int>(setting)]);
+}
+
+const Feature kInstantWarp{"InstantWarp", nullptr, InstallInstantWarp, InstantWarpUpdate};
diff --git a/mods/src/patches/parts/instant_warp_confirmation.cc b/mods/src/patches/parts/instant_warp_confirmation.cc
deleted file mode 100644
index 6a3429f2c..000000000
--- a/mods/src/patches/parts/instant_warp_confirmation.cc
+++ /dev/null
@@ -1,73 +0,0 @@
-#include "config.h"
-#include "patches/instant_warp_policy.h"
-#include "ship_name_match.h"
-
-#include <prime/CourseData.h>
-#include <prime/CoursePromptPopupWidget.h>
-
-#include <spud/detour.h>
-
-#include <spdlog/spdlog.h>
-
-#include <algorithm>
-
-namespace
-{
-void CoursePromptPopupViewController_AboutToShow_Hook(auto original, CoursePromptPopupViewController* _this)
-{
-  original(_this);
-
-  const auto widget  = _this == nullptr ? nullptr : _this->PopupWidget();
-  const auto context = widget == nullptr ? nullptr : widget->Context();
-  if (context == nullptr || !context->HasInstantWarp()) {
-    return;
-  }
-
-  FleetPlayerData* fleet = nullptr;
-  if (const auto course = context->GetCourseData(); course != nullptr)
-    fleet = course->PlayerFleet();
-  const auto action = ResolveInstantWarpConfirmation(fleet);
-  spdlog::debug("InstantWarpConfirmation: resolved action {}", static_cast<int>(action));
-  switch (action) {
-    case InstantWarpConfirmation::Warp:
-      widget->InitiateRegularWarp();
-      break;
-    case InstantWarpConfirmation::Jump:
-      widget->OnInstantWarpButtonClick();
-      break;
-    case InstantWarpConfirmation::None:
-      break;
-  }
-}
-} // namespace
-
-InstantWarpConfirmation ResolveInstantWarpConfirmation(FleetPlayerData* fleet)
-{
-  const auto& cfg           = Config::Get();
-  const auto  display_words = ShipNameMatch::DisplayWords(fleet);
-  const auto  matches       = [&display_words](const std::vector<std::string>& names, bool all) {
-    return all || (!display_words.empty() && std::ranges::any_of(names, [&](const auto& configured) {
-             return ShipNameMatch::MatchesDisplay(display_words, ShipNameMatch::SplitWords(configured));
-           }));
-  };
-  if (matches(cfg.instant_warp_always_ask, cfg.instant_warp_always_ask_all))
-    return InstantWarpConfirmation::None;
-  if (matches(cfg.instant_warp_auto_jump, cfg.instant_warp_auto_jump_all))
-    return InstantWarpConfirmation::Jump;
-  if (matches(cfg.instant_warp_auto_warp, cfg.instant_warp_auto_warp_all))
-    return InstantWarpConfirmation::Warp;
-  return cfg.auto_confirm_instant_warp;
-}
-
-void InstallInstantWarpConfirmationHooks()
-{
-  // The hook is useless without both popup actions, so skip it (and the label) when either has drifted.
-  const auto about_to_show = CoursePromptPopupViewController::Class::Method("AboutToShow", 0);
-  if (!about_to_show || !CoursePromptPopupWidget::Class::Method("InitiateRegularWarp", 0)
-      || !CoursePromptPopupWidget::Class::Method("OnInstantWarpButtonClick", 0)) {
-    return;
-  }
-
-  if (SPUD_STATIC_DETOUR(about_to_show.Pointer(), CoursePromptPopupViewController_AboutToShow_Hook))
-    InstallWarpActionLabel();
-}
diff --git a/mods/src/patches/parts/interior_zoom.cc b/mods/src/patches/parts/interior_zoom.cc
index e651fbced..0733cfe6e 100644
--- a/mods/src/patches/parts/interior_zoom.cc
+++ b/mods/src/patches/parts/interior_zoom.cc
@@ -1,12 +1,12 @@
 #include "config.h"
-#include "errormsg.h"
+#include "patches/patches.h"
 
-#include <il2cpp/il2cpp_helper.h>
+#include "prime/navigation.h"
+#include <il2cpp/hook.h>
 
 #include <prime/Hub.h>
 
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
 
 #include <cmath>
 #include <cstring>
@@ -20,13 +20,6 @@
 // haven_zoom.cc.
 namespace
 {
-FieldInfo *provider_constraint = nullptr; // AbstractOrbitFrameProvider._constraint -> OrbitConstraint
-FieldInfo *constraint_radius   = nullptr; // OrbitConstraint._radius -> Constraint.FloatData
-FieldInfo *radius_enabled      = nullptr; // Constraint.FloatData._enabled
-FieldInfo *radius_min          = nullptr; // Constraint.FloatData._min
-FieldInfo *radius_max          = nullptr; // Constraint.FloatData._max
-bool       fields_ok           = false;
-
 struct NativeRange {
   float min, max;
 };
@@ -35,33 +28,30 @@ struct NativeRange {
 // exterior camera, so provider-keying stranded the exterior at a widened radius it never restored. The
 // pointer is only a map key (the stored value is plain floats), so a retired object cannot cause a
 // stale-object access.
-std::unordered_map<Il2CppObject *, NativeRange> g_native;
-bool                                            g_reported = false;
+std::unordered_map<InteriorRadiusConstraint*, NativeRange> g_native;
+bool                                                       g_reported = false;
 
 float InteriorScale()
 {
-  const auto scale = Config::Get().interior_zoom_scale;
+  const auto scale = Config::Get().graphics.interior_zoom_scale;
   return (std::isfinite(scale) && scale > 1.0f) ? scale : 1.0f;
 }
 
-void OrbitFrameProvider_UpdateConstrains_Hook(auto original, Il2CppObject *provider, void *camera)
+void OrbitFrameProvider_UpdateConstrains_Hook(auto original, OrbitFrameProvider* provider, void* camera)
 {
-  if (!fields_ok || provider == nullptr) {
+  if (provider == nullptr) {
     original(provider, camera);
     return;
   }
 
-  Il2CppObject *constraint = nullptr, *radius = nullptr;
-  il2cpp_field_get_value(provider, provider_constraint, &constraint);
-  if (constraint != nullptr) {
-    il2cpp_field_get_value(constraint, constraint_radius, &radius);
-  }
+  auto* constraint = provider->As<InteriorOrbitProvider>()->Constraint();
+  auto* radius     = constraint ? constraint->Radius() : nullptr;
   if (radius == nullptr) {
     original(provider, camera);
     return;
   }
 
-  auto      *section_manager = Hub::get_SectionManager();
+  auto*      section_manager = Hub::Sections();
   const bool in_interior =
       section_manager != nullptr && section_manager->CurrentSection() == SectionID::Starbase_Interior;
   const float scale = InteriorScale();
@@ -71,14 +61,11 @@ void OrbitFrameProvider_UpdateConstrains_Hook(auto original, Il2CppObject *provi
     auto it = g_native.find(radius);
     if (it == g_native.end()) {
       NativeRange nr{0.0f, 0.0f};
-      il2cpp_field_get_value(radius, radius_min, &nr.min);
-      il2cpp_field_get_value(radius, radius_max, &nr.max);
-      it = g_native.emplace(radius, nr).first;
+      nr.min = radius->Minimum();
+      nr.max = radius->Maximum();
+      it     = g_native.emplace(radius, nr).first;
       if (!g_reported) {
-        bool enabled = false;
-        if (radius_enabled) {
-          il2cpp_field_get_value(radius, radius_enabled, &enabled);
-        }
+        const bool enabled = radius->Enabled();
         spdlog::info("[InteriorZoom] interior orbit endpoint native radius min={} max={} enabled={} (scale={})", nr.min,
                      nr.max, enabled, scale);
         g_reported = true;
@@ -90,16 +77,16 @@ void OrbitFrameProvider_UpdateConstrains_Hook(auto original, Il2CppObject *provi
     // (min==max) simply relocates farther out; a real range stretches outward.
     float new_min = it->second.min * scale;
     float new_max = it->second.max * scale;
-    il2cpp_field_set_value(radius, radius_min, &new_min);
-    il2cpp_field_set_value(radius, radius_max, &new_max);
+    radius->SetMinimum(new_min);
+    radius->SetMaximum(new_max);
   } else {
     // Not the interior (or feature off): the far endpoint is SHARED with the exterior view, so restore
     // native on any radius we widened, else the exterior stays zoomed out and its labels drop out of LOD.
     auto it = g_native.find(radius);
     if (it != g_native.end()) {
       float native_min = it->second.min, native_max = it->second.max;
-      il2cpp_field_set_value(radius, radius_min, &native_min);
-      il2cpp_field_set_value(radius, radius_max, &native_max);
+      radius->SetMinimum(native_min);
+      radius->SetMaximum(native_max);
     }
   }
 
@@ -107,58 +94,20 @@ void OrbitFrameProvider_UpdateConstrains_Hook(auto original, Il2CppObject *provi
 }
 } // namespace
 
+namespace
+{
 void InstallInteriorZoomHooks()
 {
-  auto orbit = il2cpp_get_class_helper("Assembly-CSharp", "Digit.Client.CameraController", "OrbitFrameProvider");
-  auto abstract_orbit =
-      il2cpp_get_class_helper("Assembly-CSharp", "Digit.Client.CameraController", "AbstractOrbitFrameProvider");
-  auto orbit_constraint =
-      il2cpp_get_class_helper("Assembly-CSharp", "Digit.Client.CameraController", "OrbitConstraint");
-  auto constraint = il2cpp_get_class_helper("Assembly-CSharp", "Digit.Client.CameraController", "Constraint");
-
-  if (!orbit.isValidHelper()) {
-    spdlog::warn("Missing class {}.{}", "CameraController", "OrbitFrameProvider");
-    return;
-  }
-
-  if (abstract_orbit.isValidHelper()) {
-    provider_constraint = abstract_orbit.GetField("_constraint").get_info();
-  }
-  if (orbit_constraint.isValidHelper()) {
-    constraint_radius = orbit_constraint.GetField("_radius").get_info();
-  }
-  if (constraint.isValidHelper()) {
-    Il2CppClass *float_data = nullptr;
-    void        *iterator   = nullptr;
-    while (auto *nested = il2cpp_class_get_nested_types(constraint.get_cls(), &iterator)) {
-      if (std::strcmp(il2cpp_class_get_name(nested), "FloatData") == 0) {
-        float_data = nested;
-        break;
-      }
-    }
-    if (float_data != nullptr) {
-      IL2CppClassHelper fd(float_data);
-      radius_enabled = fd.GetField("_enabled").get_info();
-      radius_min     = fd.GetField("_min").get_info();
-      radius_max     = fd.GetField("_max").get_info();
-    }
-  }
-
-  fields_ok =
-      provider_constraint != nullptr && constraint_radius != nullptr && radius_min != nullptr && radius_max != nullptr;
-  if (!fields_ok) {
-    spdlog::warn("[InteriorZoom] orbit-constraint fields not resolved; interior zoom disabled, native behavior kept");
+  const bool ready = InteriorOrbitProvider::Class::HasField<"_constraint", InteriorOrbitConstraint*>()
+                     && InteriorOrbitConstraint::Class::HasField<"_radius", InteriorRadiusConstraint*>()
+                     && InteriorRadiusConstraint::Class::HasField<"_min", float>()
+                     && InteriorRadiusConstraint::Class::HasField<"_max", float>();
+  if (!ready) {
+    spdlog::warn("[InteriorZoom] orbit-constraint fields not resolved; native behavior kept");
     return;
   }
-
-  auto ptr_update_constrains = orbit.GetMethod("UpdateConstrains");
-  if (ptr_update_constrains == nullptr) {
-    spdlog::warn("Missing method {}.{}", "OrbitFrameProvider", "UpdateConstrains");
-    return;
-  }
-  if (SPUD_STATIC_DETOUR(ptr_update_constrains, OrbitFrameProvider_UpdateConstrains_Hook)) {
-    spdlog::info("[InteriorZoom] installed interior orbit-endpoint hook (scale={})", InteriorScale());
-  } else {
-    spdlog::warn("[InteriorZoom] OrbitFrameProvider.UpdateConstrains detour failed; native behavior kept");
-  }
+  IL2CPP_HOOK(OrbitFrameProvider::Class::Method("UpdateConstrains"), OrbitFrameProvider_UpdateConstrains_Hook);
 }
+} // namespace
+
+const Feature kInteriorZoom{"InteriorZoom", &Config::Patches::interiorzoomhooks, InstallInteriorZoomHooks};
diff --git a/mods/src/patches/parts/loading_screen.cc b/mods/src/patches/parts/loading_screen.cc
index e8de485ea..905adb8b4 100644
--- a/mods/src/patches/parts/loading_screen.cc
+++ b/mods/src/patches/parts/loading_screen.cc
@@ -1,83 +1,429 @@
-#include "loading_screen_common.h"
+// The mod's loading screens: the login background and logos, the transition screen between sections, and the
+// loading tips. They share the embedded images and reset together when the game reloads.
 
-#include <spud/detour.h>
+#include "config.h"
+#include "patches/patches.h"
+#include "version.h"
 
-namespace ls = ls_common;
+#include "prime/loading.h"
+#include "prime/ui.h"
+
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
+#include <spdlog/spdlog.h>
+#include <unity/ui.h>
+
+#include <array>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <random>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+// Generated into the Zig build cache from assets/ (or -Dbg_image).
+#include "embedded_cc_logo_image.h"
+#include "embedded_loading_image.h"
+#include "embedded_logo_image.h"
 
 namespace
 {
-struct LoginSequence : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Login", "LoginSequence">;
+void ShowSprite(unity::Image* image, unity::Sprite* sprite, bool preserve_aspect)
+{
+  image->SetSprite(sprite);
+  image->SetColor({1.0f, 1.0f, 1.0f, 1.0f});
+  image->SetType(unity::Image::Type::Simple);
+  image->SetPreserveAspect(preserve_aspect);
+  image->SetRaycastTarget(false);
+}
+
+void HideImage(unity::Image* image)
+{
+  if (image)
+    image->SetColor({0.0f, 0.0f, 0.0f, 0.0f});
+}
+
+// Decodes `data` into `asset` unless it is still loaded; warns once per failed decode.
+unity::ImageAsset* Load(unity::ImageAsset& asset, const uint8_t* data, size_t size, const char* name)
+{
+  if (asset.Load(data, size))
+    return &asset;
+  spdlog::warn("[LS] failed to load {} texture", name);
+  return nullptr;
+}
 
-  Component* mainCanvas()
-  { return Field<"_mainCanvas", Component*>(); }
+struct Assets {
+  unity::ImageAsset background, logo, community_logo;
+
+  // The configured loader_image, or the embedded one when it is unset or unreadable. Called from hooks, so it
+  // never throws.
+  unity::ImageAsset* Background()
+  {
+    if (background.Texture())
+      return &background;
+    const auto&     path = Config::Get().graphics.loader_image;
+    std::error_code error;
+    if (!path.empty() && std::filesystem::exists(path, error)) {
+      std::ifstream        file(path, std::ios::binary);
+      std::vector<uint8_t> data(std::istreambuf_iterator<char>(file), {});
+      if (!data.empty() && Load(background, data.data(), data.size(), "custom loading background"))
+        return &background;
+    }
+    return Load(background, g_embeddedLoadingImage, g_embeddedLoadingImage_SIZE, "embedded loading background");
+  }
+
+  unity::ImageAsset* Logo()
+  { return Load(logo, g_embeddedLogoImage, g_embeddedLogoImage_SIZE, "mod logo"); }
+
+  unity::ImageAsset* CommunityLogo()
+  { return Load(community_logo, g_embeddedCCLogoImage, g_embeddedCCLogoImage_SIZE, "community logo"); }
 };
-} // namespace
+// Never destroyed: its GC handles must not be freed by static destructors after the runtime is gone.
+Assets& assets = *new Assets;
 
-static GameObject* g_loginLogoGO    = nullptr;
-static GameObject* g_loginCCLogoGO  = nullptr;
+unity::GameObject* CreateOverlay(const char* name, unity::ImageAsset& asset, unity::Transform* parent,
+                                 unity::Vector2 anchor_min, unity::Vector2 anchor_max, bool preserve_aspect,
+                                 bool behind_siblings)
+{
+  auto* sprite    = parent ? asset.Sprite() : nullptr;
+  auto* object    = sprite ? unity::GameObject::Create(name) : nullptr;
+  auto* transform = object ? object->GetComponent<unity::Transform>() : nullptr;
+  if (!transform)
+    return nullptr;
+  // Attached to the canvas root, so the overlay covers the whole screen.
+  transform->SetParent(unity::CanvasRoot(parent), false);
+  if (behind_siblings)
+    transform->SetAsFirstSibling();
+
+  // Adding a Graphic turns the plain Transform into a RectTransform.
+  auto* image = object->AddComponent<unity::Image>();
+  auto* rect  = image ? object->GetComponent<unity::RectTransform>() : nullptr;
+  if (!rect)
+    return nullptr;
+  rect->Place(anchor_min, anchor_max, {0.5f, 0.5f}, {0.0f, 0.0f}, {0.0f, 0.0f});
+  ShowSprite(image, sprite, preserve_aspect);
+  return object;
+}
 
-void ResetLoadingScreenState()
+enum class Corner { kBottomLeft, kBottomRight };
+
+// A logo in a bottom corner, sized relative to a 1920-wide screen and scaled by loader_logo_scale.
+bool CreateLogo(const char* name, unity::ImageAsset* asset, unity::Transform* parent, Corner corner)
 {
-  g_loginLogoGO   = nullptr;
-  g_loginCCLogoGO = nullptr;
+  if (!asset || !parent)
+    return false;
+
+  float width  = static_cast<float>(unity::Screen::width());
+  float height = static_cast<float>(unity::Screen::height());
+  if (width <= 0.0f)
+    width = 1334.0f;
+  if (height <= 0.0f)
+    height = 750.0f;
+
+  const float scale       = width / 1920.0f * Config::Get().graphics.loader_logo_scale;
+  const float logo_width  = 150.0f * scale;
+  const float logo_height = logo_width * asset->AspectRatio();
+  const float pad_x       = 30.0f * scale;
+  const float pad_y       = 185.0f * scale;
+  const float left        = corner == Corner::kBottomLeft ? pad_x : width - pad_x - logo_width;
+
+  return CreateOverlay(name, *asset, parent, {left / width, pad_y / height},
+                       {(left + logo_width) / width, (pad_y + logo_height) / height}, true, false);
 }
 
-static Image* FindLoginBGImage(Transform* transform, int depth, int maxDepth, Image** outFirst)
+// The mod logo on the right, the community logo on the left.
+struct Logos {
+  bool logo           = false;
+  bool community_logo = false;
+
+  // Creates whichever is still missing.
+  void Create(unity::Transform* parent)
+  {
+    logo           = logo || CreateLogo("STFCModLogo", assets.Logo(), parent, Corner::kBottomRight);
+    community_logo = community_logo || CreateLogo("STFCCCLogo", assets.CommunityLogo(), parent, Corner::kBottomLeft);
+  }
+};
+
+// --- Login sequence ---
+
+// The login screen's background image: the first child Image with a known background name, or else the first
+// Image found at all, searching four levels deep.
+unity::Image* FindLoginBackground(unity::Transform* transform, int depth, unity::Image*& first)
 {
-  if (!transform || depth > maxDepth) return nullptr;
-  int32_t n = transform->childCount();
-  for (int32_t i = 0; i < n; ++i) {
-    auto* child = transform->GetChild(i);
-    if (!child) continue;
-    auto* cgo = child->gameObject();
-    if (!cgo) continue;
-    if (auto* img = cgo->GetComponent<Image>()) {
-      if (!*outFirst) *outFirst = img;
-      const auto name = cgo->Name();
-      if (name == "Background" || name == "BG" || name == "bg_image" || name == "LoadingBackground"
-          || name == "LoginBG" || name == "SplashBG" || name == "Image")
-        return img;
+  static constexpr std::string_view kNames[] = {"Background", "BG",       "bg_image", "LoadingBackground",
+                                                "LoginBG",    "SplashBG", "Image"};
+  if (!transform || depth > 4)
+    return nullptr;
+  for (int32_t i = 0; i < transform->childCount(); ++i) {
+    auto* child  = transform->GetChild(i);
+    auto* object = child ? child->gameObject() : nullptr;
+    if (!object)
+      continue;
+    if (auto* image = object->GetComponent<unity::Image>()) {
+      if (!first)
+        first = image;
+      if (std::ranges::find(kNames, object->Name()) != std::end(kNames))
+        return image;
     }
-    if (auto* found = FindLoginBGImage(child, depth + 1, maxDepth, outFirst)) return found;
+    if (auto* found = FindLoginBackground(child, depth + 1, first))
+      return found;
   }
   return nullptr;
 }
 
-static void LS_LoginSequence_Awake_Hook(auto original, LoginSequence* _this)
+void LoginSequence_Awake_Hook(auto original, LoginSequence* _this)
 {
   original(_this);
+  if (!Config::Get().graphics.loader_enabled)
+    return;
+
+  auto* background = assets.Background();
+  auto* canvas     = background ? _this->mainCanvas() : nullptr;
+  auto* root       = canvas ? canvas->transform() : nullptr;
+  if (!root)
+    return;
+
+  unity::Image* first = nullptr;
+  auto*         image = FindLoginBackground(root, 0, first);
+  if (!image)
+    image = first;
+  if (!image)
+    return;
+
+#ifndef _USE_ORIGINAL_BG
+  if (auto* sprite = background->Sprite()) {
+    image->SetOverrideSprite(sprite);
+    ShowSprite(image, sprite, false);
+    image->SetVerticesDirty();
+  }
+#endif
+  Logos{}.Create(image->transform());
+}
+
+// --- Loading tips ---
+
+struct Tip {
+  const char* text;
+  int         weight;
+};
+
+constexpr Tip kTips[] = {
+    {"Did you know? You can customize zoom presets, hotkeys, and UI scale in the community mod settings file to suit "
+     "your playstyle.",
+     15},
+    {"The community mod supports custom loading screens, transition backgrounds, and borderless fullscreen mode for a "
+     "better experience.",
+     10},
+    {"Press F11 at any time to toggle between borderless fullscreen and windowed mode without restarting the game or "
+     "losing your session.",
+     15},
+    {"Visit https://stfc.pro to track player rankings and stats across over 236,000 players and 114 servers in Star "
+     "Trek Fleet Command.",
+     50},
+    {"Join the community Discord server to report bugs, request new features, and stay up to date with the latest mod "
+     "releases and updates.",
+     10},
+};
 
-  if (!Config::Get().loader_enabled) return;
+// The first loading screen of a session gets the welcome line. After that, half the transition screens keep the
+// game's own tip and the rest get one of ours by weight, never the same one twice in a row.
+struct Tips {
+  bool         first_screen = true;
+  size_t       last         = std::size(kTips);
+  std::mt19937 random{std::random_device{}()};
 
-  ResetLoadingScreenState();
-  ls::ResetLoadingAssetsForScene();
+  const char* Next()
+  {
+    if (std::exchange(first_screen, false))
+      return "Welcome to Star Trek Fleet Command, Supported by the Community Mod "
+             "v" VER_FILE_VERSION_STR VERSION_PATCH_STR "! Please check our discord for the latest information!";
+    if (std::bernoulli_distribution(0.5)(random))
+      return nullptr;
 
-  auto* asset = ls::GetLoadingAsset();
-  if (!asset) return;
+    std::array<int, std::size(kTips)> weights{};
+    for (size_t i = 0; i < weights.size(); ++i)
+      weights[i] = i == last ? 0 : kTips[i].weight;
+    last = std::discrete_distribution<size_t>(weights.begin(), weights.end())(random);
+    return kTips[last].text;
+  }
+
+  void Reset()
+  {
+    first_screen = true;
+    last         = std::size(kTips);
+  }
+} tips;
 
-  auto* canvas = _this->mainCanvas();
-  if (!canvas) return;
-  auto* canvasTrans = canvas->transform();
-  if (!canvasTrans) return;
+void LoadingTipViewController_SetRandomTipLocalisedText_Hook(auto original, LoadingTipViewController* _this)
+{
+  original(_this);
+  if (!Config::Get().graphics.loader_tip_enabled)
+    return;
+  auto* label = _this->textMeshPro();
+  if (const char* tip = tips.Next(); tip && label)
+    label->SetText(tip);
+}
 
-  Image* first = nullptr;
-  auto*  bgImg = FindLoginBGImage(canvasTrans, 0, 4, &first);
-  if (!bgImg) bgImg = first;
-  if (!bgImg) return;
+// --- Transition screen ---
 
+// What has been done to the current TransitionViewController. Its Unity objects are looked up again on each
+// attempt rather than kept, since nothing roots them between hooks. A new controller or a reload starts over.
+struct Transition {
+  bool  customized = false;
+  bool  overlay    = false;
+  Logos logos;
+} transition;
+
+// The transition background: _staticOverride, or the Image on BGContainer's first child (whose transform is
+// returned in `box` so it can be stretched).
+unity::Image* FindTransitionBackground(TransitionViewController* controller, unity::Transform*& box)
+{
+  if (auto* image = controller->staticOverride())
+    return image;
+  auto* root = controller->transform();
+  for (int32_t i = 0; root && i < root->childCount(); ++i) {
+    auto* child  = root->GetChild(i);
+    auto* object = child ? child->gameObject() : nullptr;
+    if (!object || object->Name() != "BGContainer")
+      continue;
+    box          = child->childCount() > 0 ? child->GetChild(0) : nullptr;
+    auto* inside = box ? box->gameObject() : nullptr;
+    return inside ? inside->GetComponent<unity::Image>() : nullptr;
+  }
+  return nullptr;
+}
+
+// Moves the game logo to the top-right corner and the tip text below centre, out of the way of the background.
+void ArrangeTransitionLayout(TransitionViewController* controller)
+{
+  auto* root = controller->transform();
+  for (int32_t i = 0; root && i < root->childCount(); ++i) {
+    auto* child  = root->GetChild(i);
+    auto* object = child ? child->gameObject() : nullptr;
+    if (!object)
+      continue;
+    const auto name = object->Name();
+    auto*      rect = object->GetComponent<unity::RectTransform>();
+    if (rect && name == "LogoContainer")
+      rect->Place({1.0f, 1.0f}, {1.0f, 1.0f}, {1.0f, 1.0f}, {586.0f, 248.0f}, {-20.0f, -20.0f});
+    else if (rect && name == "LoadingTipsContainer")
+      rect->Place({0.5f, 0.5f}, {0.5f, 0.5f}, {0.5f, 0.5f}, {1024.0f, 100.0f}, {0.0f, -320.0f});
+  }
+}
+
+// Runs from Awake and again from AboutToShow until it succeeds.
+void CustomizeTransition(TransitionViewController* controller)
+{
+  unity::Transform* box        = nullptr;
+  auto*             background = FindTransitionBackground(controller, box);
+  if (!background)
+    return;
+  auto* parent = box ? box : background->transform();
+
+  // The canvas animation would fade our overlay; AboutToHide switches it back on for the hide animation.
+  if (auto* animator = controller->animator())
+    animator->SetEnabled(false);
+
+  if (!Config::Get().graphics.loader_transition_black) {
 #ifndef _USE_ORIGINAL_BG
-  ls::ApplySpriteToImage(bgImg, *asset);
+    if (parent && !transition.overlay)
+      if (auto* image = assets.Background())
+        transition.overlay =
+            CreateOverlay("STFCModBG", *image, parent, {0.0f, 0.0f}, {1.0f, 1.0f}, false, true) != nullptr;
+    // Keep the game's background unless the replacement is fully attached, so a failure is visible but harmless.
+    if (!transition.overlay) {
+      spdlog::warn("[LS] custom transition background unavailable; preserving game background");
+      return;
+    }
+    HideImage(background);
+    if (box) {
+      box->As<unity::RectTransform>()->Place({0.0f, 0.0f}, {1.0f, 1.0f}, {0.5f, 0.5f}, {0.0f, 0.0f}, {0.0f, 0.0f});
+      box->SetLocalEulerAngles({0, 0, 0});
+      box->SetLocalScale({1, 1, 1});
+    }
 #endif
-
-  if (auto* bgImgTr = bgImg->transform()) {
-    ls::CreateLogoOverlay(bgImgTr, g_loginLogoGO);
-    ls::CreateCCLogoOverlay(bgImgTr, g_loginCCLogoGO);
   }
+
+  if (parent)
+    transition.logos.Create(parent);
+  if (!Config::Get().graphics.loader_transition_black)
+    ArrangeTransitionLayout(controller);
+  transition.customized = true;
+}
+
+void TransitionViewController_Awake_Hook(auto original, TransitionViewController* _this)
+{
+  original(_this);
+  if (!Config::Get().graphics.loader_transition)
+    return;
+  transition = {};
+  CustomizeTransition(_this);
 }
 
-void InstallLoadingScreenHooks()
+void TransitionViewController_AboutToShow_Hook(auto original, TransitionViewController* _this)
 {
-  if (auto m = LoginSequence::Class::Method("Awake"))
-    SPUD_STATIC_DETOUR(m.Pointer(), LS_LoginSequence_Awake_Hook);
+  original(_this);
+  if (Config::Get().graphics.loader_transition && !transition.customized)
+    CustomizeTransition(_this);
 }
+
+void TransitionViewController_AboutToHide_Hook(auto original, TransitionViewController* _this)
+{
+  if (auto* animator = _this->animator(); animator && Config::Get().graphics.loader_transition)
+    animator->SetEnabled(true);
+  original(_this);
+}
+
+void SlideShowViewController_ShowCurrentSlide_Hook(auto original, SlideShowViewController* _this)
+{
+  original(_this);
+  const auto& config = Config::Get();
+  if (config.graphics.loader_transition && !config.graphics.loader_transition_black)
+    HideImage(_this->image());
+}
+
+// The hierarchy holding our overlays is destroyed during a reload; forget it so Awake does not touch dead objects.
+void MonoSingleton_PrepareAllForReload_Hook(auto original)
+{
+  transition = {};
+  tips.Reset();
+  original();
+}
+
+// Shared by the login, tip and transition installs, whichever of them run.
+void InstallReloadReset()
+{
+  static bool installed = false;
+  if (std::exchange(installed, true))
+    return;
+  IL2CPP_HOOK(MonoSingletonBase::Method("PrepareAllForReload"), MonoSingleton_PrepareAllForReload_Hook);
+}
+
+void InstallLoginScreen()
+{
+  InstallReloadReset();
+  IL2CPP_HOOK(LoginSequence::Class::Method("Awake"), LoginSequence_Awake_Hook);
+}
+
+void InstallTransitionScreen()
+{
+  InstallReloadReset();
+  IL2CPP_HOOK(TransitionViewController::Class::Method("Awake"), TransitionViewController_Awake_Hook);
+  IL2CPP_HOOK(TransitionViewController::Class::Method("AboutToShow"), TransitionViewController_AboutToShow_Hook);
+  IL2CPP_HOOK(TransitionViewController::Class::Method("AboutToHide"), TransitionViewController_AboutToHide_Hook);
+  IL2CPP_HOOK(SlideShowViewController::Class::Method("ShowCurrentSlide"),
+              SlideShowViewController_ShowCurrentSlide_Hook);
+}
+
+void InstallLoadingTips()
+{
+  InstallReloadReset();
+  IL2CPP_HOOK(LoadingTipViewController::Class::Method("SetRandomTipLocalisedText"),
+              LoadingTipViewController_SetRandomTipLocalisedText_Hook);
+}
+} // namespace
+
+const Feature kLoginScreen{"LoginScreen", &Config::Patches::loadingscreenhooks, InstallLoginScreen};
+const Feature kTransitionScreen{"TransitionScreen", &Config::Patches::transitionscreenhooks, InstallTransitionScreen};
+const Feature kLoadingTips{"LoadingTips", &Config::Patches::loadingtiphooks, InstallLoadingTips};
diff --git a/mods/src/patches/parts/loading_screen_common.h b/mods/src/patches/parts/loading_screen_common.h
deleted file mode 100644
index 348d867de..000000000
--- a/mods/src/patches/parts/loading_screen_common.h
+++ /dev/null
@@ -1,360 +0,0 @@
-#pragma once
-
-#include "config.h"
-
-#include <prime/Canvas.h>
-#include <prime/Color.h>
-#include <prime/Component.h>
-#include <prime/GameObject.h>
-#include <prime/Image.h>
-#include <prime/RectTransform.h>
-#include <prime/Transform.h>
-#include <prime/Vector2.h>
-
-#include <il2cpp/il2cpp.h>
-#include <spdlog/spdlog.h>
-
-#include <cstring>
-#include <filesystem>
-#include <fstream>
-#include <vector>
-
-// Embedded image headers (auto-generated by xmake before_build)
-#include "embedded_loading_image.h"
-#include "embedded_logo_image.h"
-#include "embedded_cc_logo_image.h"
-
-
-namespace ls_common {
-
-struct Rect { float x, y, width, height; };
-
-struct Texture2D : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Texture2D">;
-};
-
-using ImageConversion = il2cpp::Class<"UnityEngine.ImageConversionModule", "UnityEngine", "ImageConversion">;
-using Screen          = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Screen">;
-using Byte            = il2cpp::Class<"mscorlib", "System", "Byte">;
-
-inline void SetFullRect(RectTransform* rt, Vector2 aMin, Vector2 aMax, Vector2 pivot, Vector2 sd, Vector2 ap)
-{
-  if (!rt) return;
-  rt->SetAnchorMin(aMin);
-  rt->SetAnchorMax(aMax);
-  rt->SetPivot(pivot);
-  rt->SetSizeDelta(sd);
-  rt->SetAnchoredPosition(ap);
-}
-
-inline Sprite* CreateSpriteFromTexture(Texture2D* tex, int32_t width, int32_t height)
-{
-  if (!tex || width <= 0 || height <= 0) return nullptr;
-  Rect    rect{0.0f, 0.0f, static_cast<float>(width), static_cast<float>(height)};
-  Vector2 pivot{0.5f, 0.5f};
-  return Sprite::Class::Call<"Create", Sprite*>(tex, rect, pivot);
-}
-
-inline void ConfigureImageSprite(Image* image, Sprite* sprite, bool preserveAspect)
-{
-  if (!image || !sprite) return;
-  image->SetSprite(sprite);
-  image->SetColor({1.0f, 1.0f, 1.0f, 1.0f});
-  image->SetType(Image::Type::Simple);
-  image->SetPreserveAspect(preserveAspect);
-  image->SetRaycastTarget(false);
-}
-
-inline void HideImage(Image* image)
-{
-  if (image) image->SetColor({0.0f, 0.0f, 0.0f, 0.0f});
-}
-
-// Overlays parent to the nearest ancestor carrying a Canvas, so they cover the whole screen.
-inline Transform* FindRootCanvas(Transform* parentTransform)
-{
-  for (auto* cur = parentTransform; cur; cur = cur->parent()) {
-    auto* game_object = cur->gameObject();
-    if (game_object && game_object->GetComponent<Canvas>())
-      return cur;
-  }
-  return parentTransform;
-}
-
-inline Texture2D* LoadTextureFromBytes(const uint8_t* data, size_t size)
-{
-  if (!data || size == 0)
-    return nullptr;
-
-  auto* bytes = il2cpp::Array<uint8_t>::New(Byte::Raw(), size);
-  if (!bytes)
-    return nullptr;
-  std::memcpy(bytes->data(), data, size);
-
-  // Texture2D(width, height, TextureFormat.RGBA32, mipChain). LoadImage resizes it.
-  auto* tex = il2cpp::New<Texture2D>(int32_t{2}, int32_t{2}, int32_t{4}, false);
-  if (!tex)
-    return nullptr;
-  if (!ImageConversion::Call<"LoadImage", bool>(tex, bytes, false))
-    return nullptr;
-  return tex;
-}
-
-// --- Texture management (shared state) ---
-
-inline uint32_t ReadBigEndian32(const uint8_t* value)
-{
-  return (static_cast<uint32_t>(value[0]) << 24) | (static_cast<uint32_t>(value[1]) << 16)
-         | (static_cast<uint32_t>(value[2]) << 8) | static_cast<uint32_t>(value[3]);
-}
-
-inline bool ReadPngDimensions(const uint8_t* data, size_t size, int32_t& width, int32_t& height)
-{
-  static constexpr uint8_t png_signature[] = {0x89, 'P', 'N', 'G', 0x0D, 0x0A, 0x1A, 0x0A};
-  if (!data || size < 24 || std::memcmp(data, png_signature, sizeof(png_signature)) != 0
-      || std::memcmp(data + 12, "IHDR", 4) != 0) {
-    return false;
-  }
-
-  const auto parsed_width  = ReadBigEndian32(data + 16);
-  const auto parsed_height = ReadBigEndian32(data + 20);
-  if (parsed_width == 0 || parsed_height == 0 || parsed_width > INT32_MAX || parsed_height > INT32_MAX) {
-    return false;
-  }
-
-  width  = static_cast<int32_t>(parsed_width);
-  height = static_cast<int32_t>(parsed_height);
-  return true;
-}
-
-// Loading assets live for one LoginSequence generation. Strong handles keep
-// the managed wrappers reachable while that generation is active; the next
-// LoginSequence releases them and creates fresh Unity native resources.
-class RootedImageAsset final
-{
-public:
-  [[nodiscard]] bool Load(const uint8_t* data, size_t size, int32_t fallback_width, int32_t fallback_height,
-                          const char* name)
-  {
-    if (Texture()) return true;
-
-    width_  = fallback_width;
-    height_ = fallback_height;
-    if (!ReadPngDimensions(data, size, width_, height_)) {
-      spdlog::warn("[LS] {} is not a supported PNG; using fallback dimensions {}x{}", name, width_, height_);
-    }
-
-    texture_handle_ = il2cpp::GcHandle::Strong(LoadTextureFromBytes(data, size));
-    if (!texture_handle_) {
-      spdlog::warn("[LS] failed to load and root {} texture", name);
-      return false;
-    }
-    name_ = name;
-    spdlog::debug("[LS] loaded and rooted {} texture ({}x{})", name_, width_, height_);
-    return true;
-  }
-
-  [[nodiscard]] Texture2D* Texture() const
-  { return texture_handle_.Get<Texture2D>(); }
-
-  [[nodiscard]] ::Sprite* Sprite()
-  {
-    if (sprite_handle_)
-      return sprite_handle_.Get<::Sprite>();
-
-    auto* texture = Texture();
-    if (!texture) return nullptr;
-    auto* sprite = CreateSpriteFromTexture(texture, width_, height_);
-    if (!sprite) {
-      spdlog::warn("[LS] failed to create {} sprite", name_);
-      return nullptr;
-    }
-
-    sprite_handle_ = il2cpp::GcHandle::Strong(sprite);
-    return sprite;
-  }
-
-  void Reset()
-  {
-    sprite_handle_.Reset();
-    texture_handle_.Reset();
-    width_  = 0;
-    height_ = 0;
-    name_   = "loading asset";
-  }
-
-  [[nodiscard]] int32_t Width() const { return width_; }
-  [[nodiscard]] int32_t Height() const { return height_; }
-
-private:
-  il2cpp::GcHandle texture_handle_;
-  il2cpp::GcHandle sprite_handle_;
-  int32_t        width_          = 0;
-  int32_t        height_         = 0;
-  const char*    name_           = "loading asset";
-};
-
-inline RootedImageAsset& LoadingAsset()
-{
-  static RootedImageAsset asset;
-  return asset;
-}
-
-inline RootedImageAsset& LogoAsset()
-{
-  static RootedImageAsset asset;
-  return asset;
-}
-
-inline RootedImageAsset& CCLogoAsset()
-{
-  static RootedImageAsset asset;
-  return asset;
-}
-
-inline void ResetLoadingAssetsForScene()
-{
-  LoadingAsset().Reset();
-  LogoAsset().Reset();
-  CCLogoAsset().Reset();
-  spdlog::debug("[LS] released previous loading assets for new LoginSequence");
-}
-
-inline RootedImageAsset* GetLoadingAsset()
-{
-  auto& asset = LoadingAsset();
-  if (asset.Texture()) return &asset;
-
-  // Hooks call this, so nothing may throw here: an unreadable path falls back to the embedded image.
-  const std::string& path = Config::Get().loader_image;
-  std::error_code    error;
-  if (!path.empty() && std::filesystem::exists(path, error)) {
-    std::ifstream f(path, std::ios::binary);
-    if (f.is_open()) {
-      std::vector<uint8_t> data(std::istreambuf_iterator<char>(f), {});
-      if (!data.empty() && asset.Load(data.data(), data.size(), 1334, 750, "custom loading background")) {
-        return &asset;
-      }
-    }
-  }
-
-  return asset.Load(g_embeddedLoadingImage, g_embeddedLoadingImage_SIZE, 1334, 750, "embedded loading background")
-             ? &asset
-             : nullptr;
-}
-
-inline RootedImageAsset* GetLogoAsset()
-{
-  auto& asset = LogoAsset();
-  return (asset.Texture() || asset.Load(g_embeddedLogoImage, g_embeddedLogoImage_SIZE, 600, 828, "mod logo"))
-             ? &asset
-             : nullptr;
-}
-
-inline RootedImageAsset* GetCCLogoAsset()
-{
-  auto& asset = CCLogoAsset();
-  return (asset.Texture()
-          || asset.Load(g_embeddedCCLogoImage, g_embeddedCCLogoImage_SIZE, 600, 815, "community logo"))
-             ? &asset
-             : nullptr;
-}
-
-inline GameObject* CreateImageOverlay(const char* name, RootedImageAsset& asset, Transform* parentTransform,
-                                     Vector2 aMin, Vector2 aMax, Vector2 pivot, Vector2 sd, Vector2 ap,
-                                     bool preserveAspect, bool placeAsFirstSibling)
-{
-  if (!parentTransform) return nullptr;
-
-  auto* spr = asset.Sprite();
-  if (!spr) return nullptr;
-
-  auto* go = il2cpp::New<GameObject>(il2cpp_string_new(name));
-  if (!go) return nullptr;
-
-  auto* tr = go->GetComponent<Transform>();
-  if (!tr) return nullptr;
-  tr->SetParent(FindRootCanvas(parentTransform), false);
-  if (placeAsFirstSibling)
-    tr->SetAsFirstSibling();
-
-  // Adding a Graphic turns the plain Transform into a RectTransform.
-  auto* image = go->AddComponent<Image>();
-  if (!image) return nullptr;
-
-  auto* rt = go->GetComponent<RectTransform>();
-  if (!rt) return nullptr;
-  SetFullRect(rt, aMin, aMax, pivot, sd, ap);
-  ConfigureImageSprite(image, spr, preserveAspect);
-
-  spdlog::debug("[LS] created {} overlay", name);
-  return go;
-}
-
-inline void CreateLogoOverlayEx(const char* name, RootedImageAsset* asset, Transform* parentTransform,
-                                GameObject*& outGO, float xSide)
-{
-  if (outGO || !asset || !parentTransform) return;
-
-  constexpr float kRefScreenWidth = 1920.0f;
-  constexpr float kRefLogoWidth   = 150.0f;
-  constexpr float kRefPadX        = 30.0f;
-  constexpr float kRefPadY        = 185.0f;
-
-  float sw = static_cast<float>(Screen::Get<"width", int32_t>());
-  float sh = static_cast<float>(Screen::Get<"height", int32_t>());
-  if (sw <= 0.0f) sw = 1334.0f;
-  if (sh <= 0.0f) sh = 750.0f;
-
-  float scale = (sw / kRefScreenWidth) * Config::Get().loader_logo_scale;
-
-  const int32_t lw = asset->Width();
-  const int32_t lh = asset->Height();
-  float logoWidth = kRefLogoWidth * scale;
-  float logoPixH  = logoWidth * ((lw > 0) ? (float)lh / (float)lw : 1.0f);
-  float padX      = kRefPadX * scale;
-  float padY      = kRefPadY * scale;
-
-  Vector2 aMin, aMax;
-  if (xSide < 0.0f) {
-    aMin = {padX / sw, padY / sh};
-    aMax = {(padX + logoWidth) / sw, (padY + logoPixH) / sh};
-  } else {
-    aMin = {(sw - padX - logoWidth) / sw, padY / sh};
-    aMax = {(sw - padX) / sw, (padY + logoPixH) / sh};
-  }
-
-  outGO = CreateImageOverlay(name, *asset, parentTransform, aMin, aMax,
-                             {0.5f, 0.5f}, {0.0f, 0.0f}, {0.0f, 0.0f},
-                             true, false);
-}
-
-inline void CreateLogoOverlay(Transform* parentTransform, GameObject*& logoGO)
-{
-  CreateLogoOverlayEx("STFCModLogo", GetLogoAsset(), parentTransform, logoGO, 1.0f);
-}
-
-inline void CreateCCLogoOverlay(Transform* parentTransform, GameObject*& ccLogoGO)
-{
-  CreateLogoOverlayEx("STFCCCLogo", GetCCLogoAsset(), parentTransform, ccLogoGO, -1.0f);
-}
-
-inline void ApplySpriteToImage(Image* image, RootedImageAsset& asset)
-{
-  if (!image) return;
-  auto* spr = asset.Sprite();
-  if (!spr) return;
-  image->SetOverrideSprite(spr);
-  ConfigureImageSprite(image, spr, false);
-  image->SetVerticesDirty();
-}
-
-inline GameObject* CreateBGOverlay(Transform* parentTransform, RootedImageAsset& asset)
-{
-  return CreateImageOverlay("STFCModBG", asset, parentTransform,
-                            {0.0f, 0.0f}, {1.0f, 1.0f}, {0.5f, 0.5f},
-                            {0.0f, 0.0f}, {0.0f, 0.0f}, false,
-                            true);
-}
-
-} // namespace ls_common
diff --git a/mods/src/patches/parts/loading_tip.cc b/mods/src/patches/parts/loading_tip.cc
deleted file mode 100644
index a1f77665f..000000000
--- a/mods/src/patches/parts/loading_tip.cc
+++ /dev/null
@@ -1,135 +0,0 @@
-#include "config.h"
-#include "version.h"
-
-#include <il2cpp/il2cpp.h>
-#include <spud/detour.h>
-
-#include <cstring>
-#include <random>
-
-namespace
-{
-static bool g_isLoadingScreen = true;
-static std::mt19937 g_rng{std::random_device{}()};
-
-struct TMP_Text : il2cpp::Object {
-  using Class = il2cpp::Class<"Unity.TextMeshPro", "TMPro", "TMP_Text">;
-
-  void SetText(Il2CppString* value)
-  { Set<"text">(value); }
-};
-
-struct LoadingTipViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Prime.LoadingScreen", "LoadingTipViewController">;
-
-  TMP_Text* textMeshPro()
-  { return Field<"_textMeshPro", TMP_Text*>(); }
-};
-
-struct TipEntry
-{
-  const char* text;
-  int         weight;
-};
-const TipEntry kCustomTips[] = {
-  {"Did you know? You can customize zoom presets, hotkeys, and UI scale in the community mod settings file to suit your playstyle.", 15},
-  {"The community mod supports custom loading screens, transition backgrounds, and borderless fullscreen mode for a better experience.", 10},
-  {"Press F11 at any time to toggle between borderless fullscreen and windowed mode without restarting the game or losing your session.", 15},
-  {"Visit https://stfc.pro to track player rankings and stats across over 236,000 players and 114 servers in Star Trek Fleet Command.", 50},
-  {"Join the community Discord server to report bugs, request new features, and stay up to date with the latest mod releases and updates.", 10},
-};
-
-constexpr size_t kNumCustomTips = std::size(kCustomTips);
-
-constexpr int kCustomTipChance    = 50;
-constexpr int kPassThroughChance  = 50;
-
-std::string GetLoadingScreenTip()
-{
-  return "Welcome to Star Trek Fleet Command, Supported by the Community Mod v"
-         VER_FILE_VERSION_STR VERSION_PATCH_STR "! Please check our discord for the latest information!";
-}
-
-void SetTMPText(TMP_Text* tmp, const std::string& text)
-{
-  if (tmp) tmp->SetText(il2cpp_string_new(text.c_str()));
-}
-
-static size_t g_lastCustomTipIdx = SIZE_MAX;
-
-std::string PickTransitionTip()
-{
-  std::uniform_int_distribution<int> rollDist(1, kCustomTipChance + kPassThroughChance);
-  int roll = rollDist(g_rng);
-
-  if (roll > kCustomTipChance)
-    return "";
-
-  if (kNumCustomTips == 0) return "";
-
-  int  totalWeight = 0;
-  int  indices[kNumCustomTips];
-  int  numCandidates = 0;
-
-  for (size_t i = 0; i < kNumCustomTips; ++i) {
-    if (i == g_lastCustomTipIdx && kNumCustomTips > 1) continue;
-    totalWeight += kCustomTips[i].weight;
-    indices[numCandidates++] = (int)i;
-  }
-
-  if (totalWeight <= 0 || numCandidates == 0) {
-    g_lastCustomTipIdx = 0;
-    return kCustomTips[0].text;
-  }
-
-  std::uniform_int_distribution<int> dist(1, totalWeight);
-  int tipRoll = dist(g_rng);
-
-  for (int j = 0; j < numCandidates; ++j) {
-    int i = indices[j];
-    tipRoll -= kCustomTips[i].weight;
-    if (tipRoll <= 0) {
-      g_lastCustomTipIdx = (size_t)i;
-      return kCustomTips[i].text;
-    }
-  }
-
-  g_lastCustomTipIdx = (size_t)indices[numCandidates - 1];
-  return kCustomTips[indices[numCandidates - 1]].text;
-}
-
-void LTVC_SetRandomTipLocalisedText_Hook(auto original, LoadingTipViewController* _this)
-{
-  original(_this);
-
-  const auto& cfg = Config::Get();
-  if (!cfg.loader_tip_enabled) return;
-
-  std::string chosenTip;
-
-  if (g_isLoadingScreen) {
-    chosenTip = GetLoadingScreenTip();
-    g_isLoadingScreen = false;
-  } else {
-    chosenTip = PickTransitionTip();
-  }
-
-  if (chosenTip.empty())
-    return;
-
-  SetTMPText(_this->textMeshPro(), chosenTip);
-}
-
-} // namespace
-
-void ResetLoadingTipState()
-{
-  g_isLoadingScreen  = true;
-  g_lastCustomTipIdx = SIZE_MAX;
-}
-
-void InstallLoadingTipHooks()
-{
-  if (auto m = LoadingTipViewController::Class::Method("SetRandomTipLocalisedText"))
-    SPUD_STATIC_DETOUR(m.Pointer(), LTVC_SetRandomTipLocalisedText_Hook);
-}
diff --git a/mods/src/patches/parts/misc.cc b/mods/src/patches/parts/misc.cc
deleted file mode 100644
index 05ecf0646..000000000
--- a/mods/src/patches/parts/misc.cc
+++ /dev/null
@@ -1,186 +0,0 @@
-#include "config.h"
-#include "prime/InterstitialViewController.h"
-
-#include <prime/BundleDataWidget.h>
-#include <prime/ClientModifierType.h>
-#include <prime/Hub.h>
-#include <prime/InventoryForPopup.h>
-#include <prime/InventoryUseRowWidget.h>
-#include <prime/ShopSummaryDirector.h>
-
-#include <il2cpp/il2cpp.h>
-
-#include <spdlog/spdlog.h>
-#include <spud/detour.h>
-
-#if _WIN32
-#include <Windows.h>
-#endif
-
-#include <algorithm>
-#include <atomic>
-#include <prime/ActionQueueManager.h>
-#include <prime/InterstitialViewController.h>
-
-namespace
-{
-constexpr int64_t kMaximumChestPurchaseMax = 160;
-}
-
-#if _WIN32
-void InventoryForPopup_set_MaxItemsToUse(auto original, InventoryForPopup* a1, int64_t a2)
-{
-  if (!a1) {
-    return;
-  }
-
-  if (a1->IsDonationUse() && a2 == 50 && Config::Get().extend_donation_slider) {
-    const auto max = Config::Get().extend_donation_max;
-    if (max > 0) {
-      a2 = max;
-    } else {
-      // Leave the initial unlimited value in place instead of applying the game's donation cap.
-      return;
-    }
-  }
-
-  original(a1, a2);
-}
-#endif
-
-// IsChestPurchase is populated too late for the existing MaxItemsToUse setter hook, so adjust the tagged context at
-// the row-render seam instead.
-void InventoryUseRowWidget_SetWidgetData(auto original, InventoryUseRowWidget* widget)
-{
-  if (widget) {
-    if (auto* context = widget->Context(); context && context->IsChestPurchase()) {
-      const auto native_max    = context->MaxItemsToUse();
-      const auto requested_max = static_cast<int64_t>(Config::Get().extend_chest_purchase_max);
-      const auto bounded_max   = std::min(requested_max, kMaximumChestPurchaseMax);
-      if (native_max > 0 && bounded_max > native_max) {
-        context->SetMaxItemsToUse(bounded_max);
-      }
-    }
-  }
-
-  original(widget);
-}
-
-#if __APPLE__
-void UnitySlider_set_maxValue(auto original, void* a1, float a2)
-{
-  if ((a2 == 50.0f || a2 == 100.0f) && Config::Get().extend_donation_slider && Config::Get().extend_donation_max > 0) {
-    a2 = (float)Config::Get().extend_donation_max;
-  }
-  original(a1, a2);
-}
-#endif
-
-void BundleDataWidget_OnActionButtonPressedCallback(auto original, BundleDataWidget* _this)
-{
-  if (_this->CurrentState() & BundleDataWidget::ItemState::CooldownTimerOn) {
-    _this->AuxViewButtonPressedHandler();
-  } else {
-    original(_this);
-  }
-}
-
-void InstallMiscPatches()
-{
-#if _WIN32
-  if (auto m = InventoryForPopup::Class::Method("set_MaxItemsToUse"))
-    SPUD_STATIC_DETOUR(m.Pointer(), InventoryForPopup_set_MaxItemsToUse);
-#endif
-
-  if (Config::Get().extend_chest_purchase_max > 0) {
-    if (auto m = InventoryUseRowWidget::Class::Method("SetWidgetData", 0))
-      SPUD_STATIC_DETOUR(m.Pointer(), InventoryUseRowWidget_SetWidgetData);
-  }
-
-#if __APPLE__
-  using Slider = il2cpp::Class<"UnityEngine.UI", "UnityEngine.UI", "Slider">;
-  if (auto m = Slider::Method("set_maxValue"))
-    SPUD_STATIC_DETOUR(m.Pointer(), UnitySlider_set_maxValue);
-#endif
-
-  if (auto m = BundleDataWidget::Class::Method("OnActionButtonPressedCallback"))
-    SPUD_STATIC_DETOUR(m.Pointer(), BundleDataWidget_OnActionButtonPressedCallback);
-}
-
-// List<IBuffData> in and out.
-il2cpp::List<il2cpp::Object*>* ExtractBuffsOfType_Hook(auto original, ClientModifierType modifier,
-                                                       il2cpp::List<il2cpp::Object*>* list)
-{
-  if (list) {
-    for (auto* item : *list) {
-      if (!item) {
-        return nullptr;
-      }
-    }
-  }
-  return original(modifier, list);
-}
-
-bool ShouldShowRevealHook(auto original, void* _this, bool ignore)
-{
-  auto result = original(_this, ignore);
-  if (Config::Get().always_skip_reveal_sequence) {
-    return false;
-  }
-  return result;
-}
-
-
-
-
-void ActionQueueManager_AddActionToQueue(auto original, ActionQueueManager* _this, int64_t fleet_id)
-{
-  spdlog::warn("ActionQueueManager_AddActionToQueue({})", fleet_id);
-  original(_this, fleet_id);
-}
-
-//   const auto section_data = Hub::get_SectionManager()->_sectionStorage->GetState(sectionID);
-
-
-std::atomic_bool popup_shown{false};
-
-bool ShouldSuppressAdditionalPopup()
-{
-  bool expected = false;
-  return !popup_shown.compare_exchange_strong(expected, true);
-}
-
-void InterstitialViewController_AboutToShow_Hook(auto original, InterstitialViewController* _this)
-{
-  original(_this);
-  if (Config::Get().only_show_first_popup && _this && ShouldSuppressAdditionalPopup())
-    _this->CloseWhenReady();
-}
-
-void ShopSceneManager_ShowPlcOfferPopup_Hook(auto original, void* _this)
-{
-  if (!Config::Get().only_show_first_popup || !ShouldSuppressAdditionalPopup())
-    original(_this);
-}
-
-void InstallTempCrashFixes()
-{
-  using BuffService = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "BuffService">;
-  if (auto m = BuffService::Method("ExtractBuffsOfType"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ExtractBuffsOfType_Hook);
-
-  using ShopSceneManager = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Shop", "ShopSceneManager">;
-  if (auto m = ShopSceneManager::Method("ShouldShowRevealSequence"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ShouldShowRevealHook);
-
-
-  // Debug-only trace, left disabled.
-  // if (auto m = ActionQueueManager::Class::Method("AddActionToQueue"))
-  //   SPUD_STATIC_DETOUR(m.Pointer(), ActionQueueManager_AddActionToQueue);
-
-  using PopupShop = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Shop", "ShopSceneManager">;
-  if (auto m = PopupShop::Method("ShowPlcOfferPopup", 0))
-    SPUD_STATIC_DETOUR(m.Pointer(), ShopSceneManager_ShowPlcOfferPopup_Hook);
-  if (auto m = InterstitialViewController::Class::Method("AboutToShow", 0))
-    SPUD_STATIC_DETOUR(m.Pointer(), InterstitialViewController_AboutToShow_Hook);
-}
diff --git a/mods/src/patches/parts/mission_hud_tweaks.cc b/mods/src/patches/parts/mission_hud_tweaks.cc
deleted file mode 100644
index 589352a2f..000000000
--- a/mods/src/patches/parts/mission_hud_tweaks.cc
+++ /dev/null
@@ -1,125 +0,0 @@
-#include "config.h"
-
-#include <il2cpp/il2cpp.h>
-#include <prime/Component.h>
-
-#include <spdlog/spdlog.h>
-#include <spud/detour.h>
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace
-{
-struct MissionsHudViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "MissionsHudViewController">;
-};
-
-// The buttons are a mix of Button and GenericButtonWidget fields; only their GameObject matters here.
-template <il2cpp::Name Field> Component* ButtonField(MissionsHudViewController* controller)
-{ return controller->Field<Field, Component*>(); }
-
-struct MissionHudButtonDefinition {
-  const char*          canonical_name;
-  Component*           (*button)(MissionsHudViewController*);
-  MissionHudVisibility visibility = MissionHudVisibility::Auto;
-};
-
-std::array<MissionHudButtonDefinition, 5> g_button_definitions{{
-    {"q_trials", ButtonField<"_challengesButton">},
-    {"field_training", ButtonField<"_achievementsButton">},
-    {"outposts", ButtonField<"_outpostsButton">},
-    {"daily_goals", ButtonField<"_dailyGoalsButton">},
-    {"missions", ButtonField<"_missionsButton">},
-}};
-
-std::vector<MissionHudButtonDefinition*> g_configured_buttons;
-
-std::string_view to_string(MissionHudVisibility visibility)
-{
-  switch (visibility) {
-    case MissionHudVisibility::Always:
-      return "always";
-    case MissionHudVisibility::Never:
-      return "never";
-    case MissionHudVisibility::Auto:
-    default:
-      return "auto";
-  }
-}
-
-std::vector<MissionHudButtonDefinition*> LoadConfiguredButtons()
-{
-  std::vector<MissionHudButtonDefinition*> configured_buttons;
-  for (auto& definition : g_button_definitions) {
-    definition.visibility = Config::Get().MissionHudButtonVisibility(definition.canonical_name);
-    configured_buttons.emplace_back(&definition);
-  }
-  return configured_buttons;
-}
-
-std::string ConfiguredButtonModes()
-{
-  std::string modes;
-  for (const auto* button : g_configured_buttons) {
-    if (button->visibility == MissionHudVisibility::Auto) {
-      continue;
-    }
-    if (!modes.empty()) {
-      modes.append(", ");
-    }
-    modes.append(button->canonical_name);
-    modes.append("=");
-    modes.append(to_string(button->visibility));
-  }
-  return modes;
-}
-
-void ApplyButtonVisibility(MissionsHudViewController* controller, const MissionHudButtonDefinition& button)
-{
-  auto* component = button.button(controller);
-  if (!component) {
-    return;
-  }
-
-  if (auto* game_object = component->gameObject()) {
-    game_object->SetActive(button.visibility == MissionHudVisibility::Always);
-  }
-}
-} // namespace
-
-int32_t MissionsHudViewController_UpdateButtons_Hook(auto original, MissionsHudViewController* controller)
-{
-  const auto result = original(controller);
-
-  for (auto* button : g_configured_buttons) {
-    button->visibility = Config::Get().MissionHudButtonVisibility(button->canonical_name);
-    if (button->visibility != MissionHudVisibility::Auto) {
-      ApplyButtonVisibility(controller, *button);
-    }
-  }
-
-  return result;
-}
-
-void InstallMissionHudTweaksHooks()
-{
-  g_configured_buttons = LoadConfiguredButtons();
-
-  auto update_buttons = MissionsHudViewController::Class::Method("UpdateButtons", 0);
-  if (!update_buttons) {
-    return;
-  }
-
-  const auto configured_modes = ConfiguredButtonModes();
-  if (!configured_modes.empty()) {
-    spdlog::info("MissionHudTweaks: applying {}", configured_modes);
-  }
-  SPUD_STATIC_DETOUR(update_buttons.Pointer(), MissionsHudViewController_UpdateButtons_Hook);
-  spdlog::info("MissionHudTweaks: installed MissionsHudViewController.UpdateButtons hook");
-}
diff --git a/mods/src/patches/parts/object_tracker.cc b/mods/src/patches/parts/object_tracker.cc
deleted file mode 100644
index 964f1fd59..000000000
--- a/mods/src/patches/parts/object_tracker.cc
+++ /dev/null
@@ -1,254 +0,0 @@
-#include "patches/object_tracker.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include "prime/AllianceStarbaseObjectViewerWidget.h"
-#include "prime/AnimatedRewardsScreenViewController.h"
-#include "prime/ArmadaObjectViewerWidget.h"
-#include "prime/ArtifactHallDetailsViewController.h"
-#include "prime/AssignShipsWidget.h"
-#include "prime/CelestialObjectViewerWidget.h"
-#include "prime/EmbassyObjectViewer.h"
-#include "prime/FleetBarViewController.h"
-#include "prime/FleetMeshSelector.h"
-#include "prime/FullScreenChatViewController.h"
-#include "prime/HousingObjectViewerWidget.h"
-#include "prime/InventoryListViewController.h"
-#include "prime/MiningObjectViewerWidget.h"
-#include "prime/OfficerAssignmentViewController.h"
-#include "prime/MissionsObjectViewerWidget.h"
-#include "prime/NavigationInteractionUIViewController.h"
-#include "prime/PreScanTargetWidget.h"
-#include "prime/ElementSelectorViewController.h"
-#include "prime/ShipManagementViewController.h"
-#include "prime/ShipManagementScreenStateViewController.h"
-#include "prime/StarNodeObjectViewerWidget.h"
-
-#include <EASTL/unordered_map.h>
-#include <EASTL/unordered_set.h>
-#include <EASTL/vector.h>
-#include <spdlog/spdlog.h>
-#include <spud/detour.h>
-#include <spud/signature.h>
-
-#include <mutex>
-
-std::mutex                                                   tracked_objects_mutex;
-eastl::unordered_map<Il2CppClass*, eastl::vector<uintptr_t>> tracked_objects;
-
-void add_to_tracking_recursive(Il2CppClass* klass, void* _this)
-{
-  if (!klass) {
-    return;
-  }
-
-  auto& tracked_object_vector = tracked_objects[klass];
-  tracked_object_vector.emplace_back(uintptr_t(_this));
-
-  return add_to_tracking_recursive(klass->parent, _this);
-}
-
-void remove_from_tracking_all(void* _this)
-{
-#define GET_CLASS(obj) ((Il2CppClass*)(((size_t)obj) & ~(size_t)1))
-  for (auto& [klass, tracked_object_vector] : tracked_objects) {
-    tracked_object_vector.erase_first(uintptr_t(_this));
-  }
-#undef GET_CLASS
-}
-
-void remove_from_tracking_recursive(Il2CppClass* klass, void* _this)
-{
-#define GET_CLASS(obj) ((Il2CppClass*)(((size_t)obj) & ~(size_t)1))
-  if (!GET_CLASS(klass)) {
-    return;
-  }
-
-  if (tracked_objects.find(klass) == tracked_objects.end()) {
-    return;
-  }
-
-  auto& tracked_object_vector = tracked_objects[GET_CLASS(klass->parent)];
-  tracked_object_vector.erase_first(uintptr_t(_this));
-  return remove_from_tracking_recursive(GET_CLASS(klass->parent), _this);
-#undef GET_CLASS
-}
-
-// Unity's Boehm GC fork passes a per-entry "finalize mark proc" as a 6th argument to
-// GC_register_finalizer_inner. GC_finalize calls it for every unreachable finalized object, and the
-// game's own registrations (via GC_register_finalizer_no_order) always pass GC_null_finalize_mark_proc,
-// a no-op. If the 6th argument is omitted, register/stack garbage ends up in the finalization entry and
-// GC_finalize eventually calls it (observed as a call to nullptr -> SIGSEGV during ReclaimUnusedMemory).
-void gc_finalize_mark_proc_noop(void*)
-{
-}
-
-void (*GC_register_finalizer_inner)(unsigned __int64 obj, void (*fn)(void*, void*), void* cd,
-                                    void (**ofn)(void*, void*), void** ocd, void (*mark_proc)(void*)) = nullptr;
-
-void track_finalizer(void* _this, void*)
-{
-  if (_this == nullptr) {
-    return;
-  }
-
-  std::scoped_lock lk{tracked_objects_mutex};
-
-  auto object = (Il2CppObject*)_this;
-  if (object->klass == nullptr) {
-    remove_from_tracking_all(_this);
-    return;
-  }
-
-#define GET_CLASS(obj) ((Il2CppClass*)(((size_t)obj) & ~(size_t)1))
-  spdlog::trace("Clearing {}({})", (void*)_this, GET_CLASS(object->klass)->name);
-  remove_from_tracking_all(_this);
-#undef GET_CLASS
-}
-
-void* track_ctor(auto original, void* _this)
-{
-  auto obj = original(_this);
-  if (_this == nullptr) {
-    return _this;
-  }
-
-  auto cls = (Il2CppObject*)_this;
-  if (cls->klass == nullptr) {
-    return obj;
-  }
-
-  std::scoped_lock lk{tracked_objects_mutex};
-  spdlog::trace("Tracking {}({})", _this, cls->klass->name);
-  if (GC_register_finalizer_inner != nullptr) {
-    typedef void (*FinalizerCallback)(void* object, void* client_data);
-    FinalizerCallback oldCallback = nullptr;
-    void*             oldData     = nullptr;
-    GC_register_finalizer_inner((intptr_t)_this, track_finalizer, nullptr, &oldCallback, &oldData,
-                                gc_finalize_mark_proc_noop);
-    assert(!oldCallback);
-  }
-  add_to_tracking_recursive(cls->klass, _this);
-  return obj;
-}
-
-void track_destroy(auto original, Il2CppObject* _this, uint64_t a2, uint64_t a3)
-{
-#define GET_CLASS(obj) ((Il2CppClass*)(((size_t)obj) & ~(size_t)1))
-  if (_this != nullptr) {
-    std::scoped_lock lk{tracked_objects_mutex};
-    spdlog::trace("Clearing {}({})", (void*)_this, GET_CLASS(_this->klass)->name);
-    remove_from_tracking_all(_this);
-  }
-  return original(_this, a2, a3);
-#undef GET_CLASS
-}
-
-void track_free(auto original, void* _this)
-{
-#define GET_CLASS(obj) ((Il2CppClass*)(((size_t)obj) & ~(size_t)1))
-  if (_this != nullptr) {
-    std::scoped_lock lk{tracked_objects_mutex};
-    auto             cls = (Il2CppObject*)_this;
-    remove_from_tracking_all(_this);
-    return original(_this);
-  }
-#undef GET_CLASS
-}
-
-void calc_liveness_hook(auto original, void* state)
-{
-  original(state);
-
-  std::scoped_lock                                    lk{tracked_objects_mutex};
-  eastl::vector<eastl::pair<Il2CppClass*, uintptr_t>> objects_to_free;
-  eastl::unordered_set<uintptr_t>                     objects_seen;
-#define IS_MARKED(obj) (((size_t)(obj)->klass) & (size_t)1)
-  for (auto& [klass, objects] : tracked_objects) {
-    for (auto object : objects) {
-      if (IS_MARKED((Il2CppObject*)object) && objects_seen.find(object) == objects_seen.end()) {
-        objects_to_free.emplace_back(klass, object);
-        objects_seen.emplace(object);
-      }
-    }
-  }
-
-#undef IS_MARKED
-
-#define GET_CLASS(obj) ((Il2CppClass*)(((size_t)obj) & ~(size_t)1))
-  for (auto& [klass, object] : objects_to_free) {
-    spdlog::trace("Clearing {}({})", (void*)object, GET_CLASS(klass)->name);
-    remove_from_tracking_all((void*)object);
-  }
-#undef GET_CLASS
-}
-
-static eastl::unordered_set<void*> seen_ctor;
-static eastl::unordered_set<void*> seen_destroy;
-
-// OnDestroy (and sometimes .ctor) resolves to a shared base implementation; detour each entry point once.
-template <typename T> void TrackObject()
-{
-  if (auto ctor = T::Class::Method(".ctor"); ctor && seen_ctor.find(ctor.Pointer()) == seen_ctor.end()) {
-    SPUD_STATIC_DETOUR(ctor.Pointer(), track_ctor);
-    seen_ctor.emplace(ctor.Pointer());
-  }
-
-  if (auto on_destroy = T::Class::Method("OnDestroy");
-      on_destroy && seen_destroy.find(on_destroy.Pointer()) == seen_destroy.end()) {
-    SPUD_STATIC_DETOUR(on_destroy.Pointer(), track_destroy);
-    seen_destroy.emplace(on_destroy.Pointer());
-  }
-}
-
-void InstallObjectTrackers()
-{
-  TrackObject<PreScanTargetWidget>();
-  TrackObject<FleetBarViewController>();
-  TrackObject<FleetMeshSelector>();
-  TrackObject<AllianceStarbaseObjectViewerWidget>();
-  TrackObject<AnimatedRewardsScreenViewController>();
-  TrackObject<ArmadaObjectViewerWidget>();
-  TrackObject<ArtifactHallDetailsViewController>();
-  TrackObject<AssignShipsWidget>();
-  TrackObject<CelestialObjectViewerWidget>();
-  TrackObject<EmbassyObjectViewer>();
-  TrackObject<FullScreenChatViewController>();
-  TrackObject<HousingObjectViewerWidget>();
-  TrackObject<InventoryListViewController>();
-  TrackObject<MiningObjectViewerWidget>();
-  TrackObject<MissionsObjectViewerWidget>();
-  TrackObject<NavigationInteractionUIViewController>();
-  TrackObject<OfficerAssignmentViewController>();
-  TrackObject<ElementSelectorViewController>();
-  TrackObject<ShipManagementViewController>();
-  TrackObject<ShipManagementScreenStateViewController>();
-  TrackObject<StarNodeObjectViewerWidget>();
-
-  SPUD_STATIC_DETOUR(il2cpp_unity_liveness_finalize, calc_liveness_hook);
-
-#if defined(__APPLE__) && defined(SPUD_ARCH_ARM64)
-  spdlog::warn("Object tracker: macOS ARM64 SPUD indirect-branch fix active; liveness-finalize hook enabled");
-#endif
-
-#if _WIN32
-  auto GC_register_finalizer_inner_matches =
-      spud::find_in_module("40 56 57 41 57 48 83 EC ? 83 3D", "GameAssembly.dll");
-#else
-#if SPUD_ARCH_ARM64
-  auto GC_register_finalizer_inner_matches = spud::find_in_module(
-    "FF ? 02 D1 FC 6F ? A9 FA 67 ? A9 F8 5F ? A9 F6 57 ? A9 F4 4F ? A9 FD 7B ? A9 FD ? 02 91 E4 0F ? A9", "GameAssembly.dylib");
-#else
-  auto GC_register_finalizer_inner_matches = spud::find_in_module(
-      "55 48 89 E5 41 57 41 56 41 55 41 54 53 48 83 EC ? 4C 89 45 ? 48 89 4D ? 83 3D", "GameAssembly.dylib");
-#endif
-#endif
-
-  if (GC_register_finalizer_inner_matches.size() == 0) {
-    spdlog::warn("Unable to resolve GC_register_finalizer_inner; object finalizers disabled");
-    return;
-  }
-
-  const auto GC_register_finalizer_inner_match = GC_register_finalizer_inner_matches[0];
-  GC_register_finalizer_inner = (decltype(GC_register_finalizer_inner))GC_register_finalizer_inner_match.address();
-}
diff --git a/mods/src/patches/parts/officer_sort.cc b/mods/src/patches/parts/officer_sort.cc
index bdaf35826..12369bd1f 100644
--- a/mods/src/patches/parts/officer_sort.cc
+++ b/mods/src/patches/parts/officer_sort.cc
@@ -1,262 +1,160 @@
+// officer_sort: brings back the "Below Deck Ability" sort option that client m93.1 removed from the officer roster
+// and the officer assignment screen, by appending it to the sort menus after the game builds them.
+
 #include "config.h"
+#include "patches/patches.h"
 #include "str_utils.h"
 
-#include <il2cpp/il2cpp.h>
+#include "prime/officers.h"
 
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
 
 #include <string>
 
-// Restores the "Below Deck Ability" (BDA) sort option removed from the game UI
-// in m93.1. Hooks OfficerSortGenerators.InitializeOfficerSorters /
-// InitializeAssignmentSorters and appends a BDA ProcessingOption after the game
-// populates its own sort lists.
-
-namespace {
-
-constexpr char kBelowDeckKey[]           = "below_deck_ability";
-constexpr char kBelowDeckAssignmentKey[] = "_below_deck_ability";
-
-using SortingPredicates = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Core", "SortingPredicates">;
-
-struct SortFunction : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.Client.Core", "SortFunction">;
-
-  // Func<object, object, int> delegates.
-  il2cpp::Object* ascending()
-  { return Field<"_ascending", il2cpp::Object*>(); }
-  void SetAscending(Il2CppObject* value)
-  { SetField<"_ascending">(value); }
-  void SetDescending(Il2CppObject* value)
-  { SetField<"_descending">(value); }
-  void SetDisplayKey(Il2CppString* value)
-  { SetField<"_displayKey">(value); }
-};
-
-struct ProcessingOption : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Sorting", "SortComparer/ProcessingOption">;
-
-  Il2CppString* displayKey()
-  { return Field<"_displayKey", Il2CppString*>(); }
-  void SetDisplayKey(Il2CppString* value)
-  { SetField<"_displayKey">(value); }
-  SortFunction* sortingOption()
-  { return Field<"_sortingOption", SortFunction*>(); }
-  void SetSortingOption(SortFunction* value)
-  { SetField<"_sortingOption">(value); }
-};
-
-struct OfficerSortGenerators : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Officers", "OfficerSortGenerators">;
-
-  il2cpp::List<SortFunction*>* rosterSorters()
-  { return Field<"_rosterSorters", il2cpp::List<SortFunction*>*>(); }
-  il2cpp::List<ProcessingOption*>* rosterOptions()
-  { return Field<"_rosterOptions", il2cpp::List<ProcessingOption*>*>(); }
-  il2cpp::List<ProcessingOption*>* assignmentOptions()
-  { return Field<"_assignmentOptions", il2cpp::List<ProcessingOption*>*>(); }
-};
-
-// Native code of the static SortingPredicates comparers. The delegates below are bound to the BDA
-// predicates but jump to the wrappers, which chain these directly.
-using SortMethodPtr = int (*)(void* obj1, void* obj2, void* delegatePtr);
-
-il2cpp::Method g_bdaAscMethod;
-il2cpp::Method g_bdaDescMethod;
-SortMethodPtr  g_unlockedStatePtr = nullptr;
-SortMethodPtr  g_bdaAscPtr        = nullptr;
-SortMethodPtr  g_bdaDescPtr       = nullptr;
-SortMethodPtr  g_indexAscPtr      = nullptr;
-// Func<object, object, int>, discovered from the game's own options; there is no binding for the
-// inflated generic class.
-Il2CppClass*   g_funcClass        = nullptr;
-
-SortMethodPtr PointerOf(il2cpp::Method method)
-{ return method ? reinterpret_cast<SortMethodPtr>(method.Info()->methodPointer) : nullptr; }
-
-// SortComparer.Compare always calls the _ascending delegate; for Descending
-// direction it negates the result. The _descending delegate is never called.
-// All logic lives in the *Ascending wrappers so that:
-//   direct call  = ascending behavior
-//   negated call = descending behavior
-
-int RosterAscendingWrapper(void* obj1, void* obj2, void* /*delegatePtr*/)
+namespace
 {
-  if (g_unlockedStatePtr) {
-    int r = g_unlockedStatePtr(obj1, obj2, nullptr);
-    if (r != 0) return r;
-  }
-  if (g_bdaDescPtr) {
-    int r = g_bdaDescPtr(obj1, obj2, nullptr);
-    if (r != 0) return r;
-  }
-  return g_indexAscPtr ? -g_indexAscPtr(obj1, obj2, nullptr) : 0;
-}
-
-int RosterDescendingWrapper(void* obj1, void* obj2, void* /*delegatePtr*/)
+constexpr char kRosterKey[]     = "below_deck_ability";
+constexpr char kAssignmentKey[] = "_below_deck_ability";
+
+// The native code of SortingPredicates' static comparers. The game's own delegates call them through the managed
+// signature; the ones the mod adds jump straight to Compare below, which chains them.
+using Comparer = int (*)(void* a, void* b, void* method);
+
+il2cpp::Method below_deck_ascending_method, below_deck_descending_method;
+Comparer       below_deck_ascending = nullptr, below_deck_descending = nullptr;
+// Tiebreakers; either may be missing, which the binding layer has already reported.
+Comparer unlocked_first = nullptr, by_index = nullptr;
+// Func<object, object, int>, taken from the game's own options: there is no binding for the inflated generic class.
+Il2CppClass* func_class = nullptr;
+
+Comparer NativeCode(il2cpp::Method method)
+{ return reinterpret_cast<Comparer>(method.Pointer()); }
+
+// SortComparer.Compare always calls the _ascending delegate and negates it for Descending; _descending is never
+// called. So each delegate is a complete comparator: unlocked officers first, then below-deck ability in the given
+// direction, then roster index (reversed for the roster, whose default direction is Ascending).
+template <Comparer* BelowDeck, int kIndexSign> int Compare(void* a, void* b, void* /*method*/)
 {
-  if (g_unlockedStatePtr) {
-    int r = g_unlockedStatePtr(obj1, obj2, nullptr);
-    if (r != 0) return r;
-  }
-  if (g_bdaAscPtr) {
-    int r = g_bdaAscPtr(obj1, obj2, nullptr);
-    if (r != 0) return r;
-  }
-  return g_indexAscPtr ? -g_indexAscPtr(obj1, obj2, nullptr) : 0;
+  if (unlocked_first)
+    if (const int order = unlocked_first(a, b, nullptr))
+      return order;
+  if (*BelowDeck)
+    if (const int order = (*BelowDeck)(a, b, nullptr))
+      return order;
+  return by_index ? kIndexSign * by_index(a, b, nullptr) : 0;
 }
 
-int AssignmentAscendingWrapper(void* obj1, void* obj2, void* /*delegatePtr*/)
+bool ResolveComparers()
 {
-  if (g_unlockedStatePtr) {
-    int r = g_unlockedStatePtr(obj1, obj2, nullptr);
-    if (r != 0) return r;
-  }
-  if (g_bdaAscPtr) {
-    int r = g_bdaAscPtr(obj1, obj2, nullptr);
-    if (r != 0) return r;
-  }
-  return g_indexAscPtr ? g_indexAscPtr(obj1, obj2, nullptr) : 0;
-}
-
-int AssignmentDescendingWrapper(void* obj1, void* obj2, void* /*delegatePtr*/)
-{
-  if (g_unlockedStatePtr) {
-    int r = g_unlockedStatePtr(obj1, obj2, nullptr);
-    if (r != 0) return r;
-  }
-  if (g_bdaDescPtr) {
-    int r = g_bdaDescPtr(obj1, obj2, nullptr);
-    if (r != 0) return r;
-  }
-  return g_indexAscPtr ? g_indexAscPtr(obj1, obj2, nullptr) : 0;
-}
-
-bool InitializePredicates()
-{
-  g_bdaAscMethod  = SortingPredicates::Method("OfficerSortByBelowDeckAbilityAscending", 2);
-  g_bdaDescMethod = SortingPredicates::Method("OfficerSortByBelowDeckAbilityDescending", 2);
-  if (!g_bdaAscMethod || !g_bdaDescMethod)
+  below_deck_ascending_method  = SortingPredicates::Method("OfficerSortByBelowDeckAbilityAscending", 2);
+  below_deck_descending_method = SortingPredicates::Method("OfficerSortByBelowDeckAbilityDescending", 2);
+  if (!below_deck_ascending_method || !below_deck_descending_method)
     return false;
-  g_bdaAscPtr  = PointerOf(g_bdaAscMethod);
-  g_bdaDescPtr = PointerOf(g_bdaDescMethod);
-
-  // The tiebreakers are optional; the library has already reported a missing one.
-  g_unlockedStatePtr = PointerOf(SortingPredicates::Method("OfficerSortByUnlockedStateAscending", 2));
-  g_indexAscPtr      = PointerOf(SortingPredicates::Method("OfficerSortByIndexAscending", 2));
-
-  // Options are allocated without a constructor below, so both classes must exist.
+  below_deck_ascending  = NativeCode(below_deck_ascending_method);
+  below_deck_descending = NativeCode(below_deck_descending_method);
+  unlocked_first        = NativeCode(SortingPredicates::Method("OfficerSortByUnlockedStateAscending", 2));
+  by_index              = NativeCode(SortingPredicates::Method("OfficerSortByIndexAscending", 2));
+  // The sort function and option are allocated without a constructor, so both classes must exist.
   return SortFunction::Class::Raw() && ProcessingOption::Class::Raw();
 }
 
-Il2CppClass* DiscoverFuncClassFromList(il2cpp::List<ProcessingOption*>* list)
-{
-  if (list->Count() < 1)
-    return nullptr;
-  auto* firstOption = (*list)[0];
-  auto* sortFn      = firstOption ? firstOption->sortingOption() : nullptr;
-  auto* ascending   = sortFn ? sortFn->ascending() : nullptr;
-  return ascending ? ascending->klass : nullptr;
-}
-
-// forRoster=true:  roster defaults to Ascending, so _ascending produces BDA-first.
-// forRoster=false: assignment defaults to Descending, so _ascending produces
-//                  non-BDA-first (SortComparer negates it, yielding BDA-first).
-SortFunction* CreateBelowDeckSortFunction(const char* displayKey, bool forRoster)
+// The roster's default direction is Ascending, so its _ascending comparer puts below-deck officers first. The
+// assignment screen defaults to Descending, so its _ascending comparer puts them last and SortComparer's negation
+// brings them first.
+SortFunction* NewSortFunction(const char* key, bool roster)
 {
-  auto* ascending = il2cpp::NewDelegate(
-      g_funcClass, g_bdaAscMethod,
-      reinterpret_cast<Il2CppMethodPointer>(forRoster ? &RosterAscendingWrapper : &AssignmentAscendingWrapper));
-  auto* descending = il2cpp::NewDelegate(
-      g_funcClass, g_bdaDescMethod,
-      reinterpret_cast<Il2CppMethodPointer>(forRoster ? &RosterDescendingWrapper : &AssignmentDescendingWrapper));
+  const auto native = [](auto compare) { return reinterpret_cast<Il2CppMethodPointer>(compare); };
+  auto*      ascending =
+      il2cpp::NewDelegate(func_class, below_deck_ascending_method,
+                          native(roster ? &Compare<&below_deck_descending, -1> : &Compare<&below_deck_ascending, 1>));
+  auto* descending =
+      il2cpp::NewDelegate(func_class, below_deck_descending_method,
+                          native(roster ? &Compare<&below_deck_ascending, -1> : &Compare<&below_deck_descending, 1>));
   if (!ascending || !descending)
     return nullptr;
 
-  // SortFunction's parameterless constructor has no generated code; set every field Compare reads.
-  auto* sort = static_cast<SortFunction*>(il2cpp_object_new(SortFunction::Class::Raw()));
-  sort->SetDisplayKey(il2cpp_string_new(displayKey));
+  // SortFunction's parameterless constructor has no generated code; every field Compare reads is set here.
+  auto* sort = il2cpp::Allocate<SortFunction>();
+  sort->SetDisplayKey(il2cpp::NewString(key));
   sort->SetAscending(ascending);
   sort->SetDescending(descending);
   return sort;
 }
 
-bool ListAlreadyHasBelowDeck(il2cpp::List<ProcessingOption*>* list)
+bool HasBelowDeckOption(il2cpp::List<ProcessingOption*>* options)
 {
-  for (auto* option : *list) {
-    auto* key = option ? option->displayKey() : nullptr;
-    if (!key)
-      continue;
-    const auto text = to_string(key);
-    if (text == kBelowDeckKey || text == kBelowDeckAssignmentKey)
+  for (auto* option : *options) {
+    const auto key = option ? il2cpp::ToUtf8(option->displayKey()) : std::string();
+    if (key == kRosterKey || key == kAssignmentKey)
       return true;
   }
   return false;
 }
 
-// If sortersList is non-null, also adds the raw SortFunction to it (the roster
-// screen builds its SortComparer from _rosterSorters, not _rosterOptions).
-void AppendBelowDeckOption(il2cpp::List<ProcessingOption*>* list, const char* displayKey, bool forRoster,
-                           il2cpp::List<SortFunction*>* sortersList = nullptr)
+// Appends the option to `options`. The roster builds its SortComparer from `sorters` rather than from the options,
+// so the sort function goes there too when given.
+void AddBelowDeckOption(il2cpp::List<ProcessingOption*>* options, const char* key, bool roster,
+                        il2cpp::List<SortFunction*>* sorters = nullptr)
 {
-  if (!list) {
-    spdlog::warn("[OfficerSort] AppendBelowDeckOption: list is null");
+  if (!options) {
+    spdlog::warn("[OfficerSort] sort option list is null");
     return;
   }
-
-  if (!g_funcClass) {
-    g_funcClass = DiscoverFuncClassFromList(list);
-    if (!g_funcClass) {
+  if (!func_class) {
+    auto* first     = options->Count() > 0 ? (*options)[0] : nullptr;
+    auto* sort      = first ? first->sortingOption() : nullptr;
+    auto* ascending = sort ? sort->ascending() : nullptr;
+    func_class      = ascending ? ascending->klass : nullptr;
+    if (!func_class) {
       spdlog::warn("[OfficerSort] could not discover Func<object,object,int> class; skipping below-deck option");
       return;
     }
   }
+  if (HasBelowDeckOption(options))
+    return;
 
-  if (ListAlreadyHasBelowDeck(list)) return;
-
-  auto* sortFn = CreateBelowDeckSortFunction(displayKey, forRoster);
-  if (!sortFn) {
+  auto* sort = NewSortFunction(key, roster);
+  if (!sort) {
     spdlog::warn("[OfficerSort] failed to create sort function");
     return;
   }
+  if (sorters)
+    sorters->Add(sort);
 
-  if (sortersList)
-    sortersList->Add(sortFn);
-
-  auto* option = static_cast<ProcessingOption*>(il2cpp_object_new(ProcessingOption::Class::Raw()));
-  option->SetDisplayKey(il2cpp_string_new(displayKey));
-  option->SetSortingOption(sortFn);
-  list->Add(option);
+  auto* option = il2cpp::Allocate<ProcessingOption>();
+  option->SetDisplayKey(il2cpp::NewString(key));
+  option->SetSortingOption(sort);
+  options->Add(option);
 }
 
-void InitializeOfficerSorters_Hook(auto original, OfficerSortGenerators* _this)
+void OfficerSortGenerators_InitializeOfficerSorters_Hook(auto original, OfficerSortGenerators* _this)
 {
   original(_this);
-  if (!Config::Get().officer_sort) return;
-  AppendBelowDeckOption(_this->rosterOptions(), kBelowDeckKey, true, _this->rosterSorters());
+  if (Config::Get().ui.officer_sort)
+    AddBelowDeckOption(_this->rosterOptions(), kRosterKey, true, _this->rosterSorters());
 }
 
-void InitializeAssignmentSorters_Hook(auto original, OfficerSortGenerators* _this)
+void OfficerSortGenerators_InitializeAssignmentSorters_Hook(auto original, OfficerSortGenerators* _this)
 {
   original(_this);
-  if (!Config::Get().officer_sort) return;
-  AppendBelowDeckOption(_this->assignmentOptions(), kBelowDeckAssignmentKey, false);
+  if (Config::Get().ui.officer_sort)
+    AddBelowDeckOption(_this->assignmentOptions(), kAssignmentKey, false);
 }
 
-} // namespace
-
-void InstallOfficerSortHooks()
+void InstallOfficerSort()
 {
-  if (!InitializePredicates())
+  if (!ResolveComparers())
     return;
-
   auto roster     = OfficerSortGenerators::Class::Method("InitializeOfficerSorters", 0);
   auto assignment = OfficerSortGenerators::Class::Method("InitializeAssignmentSorters", 0);
   if (!roster || !assignment)
     return;
-
-  SPUD_STATIC_DETOUR(roster.Pointer(), InitializeOfficerSorters_Hook);
-  SPUD_STATIC_DETOUR(assignment.Pointer(), InitializeAssignmentSorters_Hook);
+  IL2CPP_HOOK(roster, OfficerSortGenerators_InitializeOfficerSorters_Hook);
+  IL2CPP_HOOK(assignment, OfficerSortGenerators_InitializeAssignmentSorters_Hook);
   spdlog::info("Officer sort: restored Below Deck Ability sort option");
 }
+} // namespace
+
+const Feature kOfficerSort{"OfficerSort", &Config::Patches::officersorthooks, InstallOfficerSort};
diff --git a/mods/src/patches/parts/open_bulk_claim_gifts.cc b/mods/src/patches/parts/open_bulk_claim_gifts.cc
index f4f90bbf3..f29683406 100644
--- a/mods/src/patches/parts/open_bulk_claim_gifts.cc
+++ b/mods/src/patches/parts/open_bulk_claim_gifts.cc
@@ -1,89 +1,179 @@
+// The shop, gift and inventory popups: auto_open_bulk_claim_flyout on the gifts screen, the chest purchase and
+// donation limits, the view button on offers that are cooling down, always_skip_reveal_sequence, and
+// disable_exchange_all on the artifact shards popup.
+
 #include "config.h"
+#include "patches/patches.h"
 
-#include <prime/Widget.h>
+#include "prime/inventory.h"
 
+#include <il2cpp/hook.h>
 #include <il2cpp/il2cpp.h>
-#include <spud/detour.h>
+
+#include <algorithm>
+#include <atomic>
 
 namespace
 {
-struct DrawerContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Prime.SharedFeatures.Scripts.UI.Widgets", "DrawerContext">;
-
-  bool Enabled()
-  { return Field<"Enabled", bool>(); }
-};
+// --- Gifts: open the bulk claim drawer ---
 
-struct DrawerWidget : Widget<DrawerContext> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Prime.SharedFeatures.Scripts.UI.Widgets", "DrawerWidget">;
+// The gifts screen that is showing, and whether its drawer was opened since it appeared.
+ShopListScrollerViewController* shown_scroller = nullptr;
+bool                            drawer_opened  = false;
 
-  void OpenViaButtonCallback()
-  { Call<"OnOpenButtonClicked">(); }
-};
+void OpenBulkClaimDrawer(ShopListScrollerViewController* controller)
+{
+  if (!Config::Get().ui.auto_open_bulk_claim_flyout || !controller || drawer_opened)
+    return;
 
-struct ShopListScrollerViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Shop", "ShopListScrollerViewController">;
+  auto* drawer  = controller->selectionDrawerWidget();
+  auto* context = drawer ? drawer->Context() : nullptr;
+  if (!context || !context->Enabled())
+    return;
 
-  DrawerWidget* SelectionDrawer()
-  { return Field<"_selectionDrawerWidget", DrawerWidget*>(); }
-};
+  // Mark first so a native callback cannot cause a nested lifecycle update to open the drawer twice.
+  drawer_opened = true;
+  drawer->OnOpenButtonClicked();
+}
 
-ShopListScrollerViewController* g_active_scroller    = nullptr;
-bool                            g_opened_for_landing = false;
+void ShopListScrollerViewController_AboutToShow_Hook(auto original, ShopListScrollerViewController* _this)
+{
+  shown_scroller = _this;
+  drawer_opened  = false;
+  original(_this);
+  OpenBulkClaimDrawer(_this);
+}
 
-void TryAutoOpenDrawer(ShopListScrollerViewController* controller)
+void ShopListScrollerViewController_AboutToHide_Hook(auto original, ShopListScrollerViewController* _this)
 {
-  if (!Config::Get().auto_open_bulk_claim_flyout || controller == nullptr || g_opened_for_landing) {
-    return;
+  if (shown_scroller == _this) {
+    shown_scroller = nullptr;
+    drawer_opened  = false;
   }
+  original(_this);
+}
 
-  auto* drawer  = controller->SelectionDrawer();
-  auto* context = drawer != nullptr ? drawer->Context() : nullptr;
-  if (context == nullptr || !context->Enabled()) {
-    return;
+// The drawer only becomes usable once the game fills it.
+void ShopListScrollerViewController_UpdateDrawer_Hook(auto original, ShopListScrollerViewController* _this)
+{
+  original(_this);
+  if (shown_scroller == _this)
+    OpenBulkClaimDrawer(_this);
+}
+
+// --- Purchase and donation limits ---
+
+// The most the game's chest purchase popup handles; extend_chest_purchase_max is clamped to it.
+constexpr int64_t kMaximumChestPurchaseMax = 160;
+
+// The popup's limits are adjusted where its row is rendered. IsChestPurchase is set too late for the MaxItemsToUse
+// setter, and adjusting the context rather than the slider leaves every other slider alone.
+void InventoryUseRowWidget_SetWidgetData_Hook(auto original, InventoryUseRowWidget* _this)
+{
+  auto*       context = _this ? _this->Context() : nullptr;
+  const auto& ui      = Config::Get().ui;
+  if (context && context->IsChestPurchase()) {
+    const auto native_max  = context->MaxItemsToUse();
+    const auto bounded_max = std::min(static_cast<int64_t>(ui.extend_chest_purchase_max), kMaximumChestPurchaseMax);
+    if (native_max > 0 && bounded_max > native_max)
+      context->SetMaxItemsToUse(bounded_max);
+  } else if (context && ui.extend_donation_slider && context->IsDonationUse()) {
+    // extend_donation_max replaces the game's donation cap; 0 or less means no cap. Either way the slider stops at
+    // what the player owns.
+    const auto owned  = context->AmountOwned();
+    auto       target = ui.extend_donation_max > 0 ? static_cast<int64_t>(ui.extend_donation_max) : owned;
+    if (owned > 0)
+      target = std::min(target, owned);
+    if (target > 0 && target != context->MaxItemsToUse())
+      context->SetMaxItemsToUse(target);
   }
+  original(_this);
+}
 
-  // Mark first so a native callback cannot cause a nested lifecycle update to open the drawer twice.
-  g_opened_for_landing = true;
-  drawer->OpenViaButtonCallback();
+// --- Offers on cooldown ---
+
+// An offer that is cooling down cannot be bought; its button opens the offer's details instead.
+void BundleDataWidget_OnActionButtonPressedCallback_Hook(auto original, BundleDataWidget* _this)
+{
+  if (_this->CurrentState() & BundleDataWidget::kCooldownTimerOn)
+    _this->AuxViewButtonPressedHandler();
+  else
+    original(_this);
 }
 
-void ShopListScrollerViewController_AboutToShow(auto original, ShopListScrollerViewController* self)
+// --- Reveal sequence ---
+
+bool ShopSceneManager_ShouldShowRevealSequence_Hook(auto original, void* _this, bool ignore)
 {
-  g_active_scroller    = self;
-  g_opened_for_landing = false;
+  const auto result = original(_this, ignore);
+  return result && !Config::Get().ui.always_skip_reveal_sequence;
+}
 
-  original(self);
-  TryAutoOpenDrawer(self);
+void InstallGiftsAutoOpen()
+{
+  using Scroller = ShopListScrollerViewController::Class;
+  IL2CPP_HOOK(Scroller::Method("AboutToShow"), ShopListScrollerViewController_AboutToShow_Hook);
+  IL2CPP_HOOK(Scroller::Method("AboutToHide"), ShopListScrollerViewController_AboutToHide_Hook);
+  IL2CPP_HOOK(Scroller::Method("UpdateDrawer"), ShopListScrollerViewController_UpdateDrawer_Hook);
 }
 
-void ShopListScrollerViewController_AboutToHide(auto original, ShopListScrollerViewController* self)
+void InstallShopLimits()
 {
-  if (g_active_scroller == self) {
-    g_active_scroller    = nullptr;
-    g_opened_for_landing = false;
-  }
+  IL2CPP_HOOK(InventoryUseRowWidget::Class::Method("SetWidgetData", 0), InventoryUseRowWidget_SetWidgetData_Hook);
+  IL2CPP_HOOK(BundleDataWidget::Class::Method("OnActionButtonPressedCallback"),
+              BundleDataWidget_OnActionButtonPressedCallback_Hook);
+}
 
-  original(self);
+// --- Artifact Exchange All ---
+
+// Hides the button after the popup binds. Individual exchanges stay available.
+void InventoryUsePopupViewController_OnDidBindCanvasContext_Hook(auto original, InventoryUsePopupViewController* _this)
+{
+  original(_this);
+  if (!_this || !Config::Get().ui.disable_exchange_all)
+    return;
+  auto* button = _this->convertAllButton();
+  if (auto* object = button ? button->gameObject() : nullptr)
+    object->SetActive(false);
 }
 
-void ShopListScrollerViewController_UpdateDrawer(auto original, ShopListScrollerViewController* self)
+
+std::atomic_bool popup_shown{false};
+
+bool ShouldSuppressAdditionalPopup()
 {
-  original(self);
+  bool expected = false;
+  return !popup_shown.compare_exchange_strong(expected, true);
+}
 
-  if (g_active_scroller == self) {
-    TryAutoOpenDrawer(self);
-  }
+void InterstitialViewController_AboutToShow_Hook(auto original, InterstitialViewController* _this)
+{
+  original(_this);
+  if (Config::Get().ui.only_show_first_popup && _this && ShouldSuppressAdditionalPopup())
+    _this->CloseWhenReady();
 }
-} // namespace
 
-void InstallGiftsBulkClaimHooks()
+void ShopSceneManager_ShowPlcOfferPopup_Hook(auto original, void* _this)
 {
-  using Scroller = ShopListScrollerViewController::Class;
-  if (auto m = Scroller::Method("AboutToShow"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ShopListScrollerViewController_AboutToShow);
-  if (auto m = Scroller::Method("AboutToHide"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ShopListScrollerViewController_AboutToHide);
-  if (auto m = Scroller::Method("UpdateDrawer"))
-    SPUD_STATIC_DETOUR(m.Pointer(), ShopListScrollerViewController_UpdateDrawer);
+  if (!Config::Get().ui.only_show_first_popup || !ShouldSuppressAdditionalPopup())
+    original(_this);
+}
+
+void InstallSkipRevealSequence()
+{ IL2CPP_HOOK(ShopSceneManager::Method("ShouldShowRevealSequence"), ShopSceneManager_ShouldShowRevealSequence_Hook); 
+  using PopupShop = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Shop", "ShopSceneManager">;
+  IL2CPP_HOOK(PopupShop::Method("ShowPlcOfferPopup", 0), ShopSceneManager_ShowPlcOfferPopup_Hook);
+  IL2CPP_HOOK(InterstitialViewController::Class::Method("AboutToShow", 0), InterstitialViewController_AboutToShow_Hook);
 }
+
+void InstallArtifactExchange()
+{
+  IL2CPP_HOOK(InventoryUsePopupViewController::Class::Method("OnDidBindCanvasContext", 0),
+              InventoryUsePopupViewController_OnDidBindCanvasContext_Hook);
+}
+} // namespace
+
+const Feature kGiftsAutoOpen{"GiftsAutoOpen", &Config::Patches::giftsbulkclaimhooks, InstallGiftsAutoOpen};
+const Feature kShopLimits{"ShopLimits", &Config::Patches::miscpatches, InstallShopLimits};
+const Feature kSkipRevealSequence{"SkipRevealSequence", &Config::Patches::tempcrashfixes, InstallSkipRevealSequence};
+const Feature kArtifactExchange{"ArtifactExchange", &Config::Patches::artifactexchangehooks, InstallArtifactExchange};
diff --git a/mods/src/patches/parts/pinned_ship_click.cc b/mods/src/patches/parts/pinned_ship_click.cc
index f2d95cd0a..1e7d816da 100644
--- a/mods/src/patches/parts/pinned_ship_click.cc
+++ b/mods/src/patches/parts/pinned_ship_click.cc
@@ -1,68 +1,71 @@
-#include "patches/object_tracker.h"
 #include "config.h"
 #include "file.h"
-#include "patches/key.h"
-#include "ship_name_match.h"
+#include "patches/patches.h"
+
+#include "str_utils.h"
 
 #include "pinned_ship_click.h"
-#include "prime/AssignShipsWidget.h"
-#include "prime/CanvasController.h"
-#include "prime/ShipManagementViewContext.h"
-#include "prime/ShipManagementViewController.h"
+#include "prime/fleet.h"
+#include "prime/ui.h"
 #include "ship_tile_click.h"
 
-#include <il2cpp/il2cpp-functions.h>
 #include <il2cpp/il2cpp.h>
+#include <unity/input.h>
+#include <unity/tracker.h>
 
 #include <spdlog/spdlog.h>
 #include <toml++/toml.h>
 
 #include <algorithm>
 #include <filesystem>
+#include <fstream>
+#include <spdlog/fmt/ranges.h>
 #include <string>
 #include <vector>
 
-namespace {
+namespace
+{
 
 bool IsShiftHeld()
-{
-  return Key::HasShift();
-}
+{ return unity::Key::Pressed(unity::KeyCode::LeftShift) || unity::Key::Pressed(unity::KeyCode::RightShift); }
 
 // Presence of a visible ShipManagementViewController instead of a SectionID
 // check: the dock is hosted under more than one game section, and this keeps
 // the gate in lockstep with the screen the pinned sort hook drives.
 bool IsShipManagementScreenVisible()
 {
-  for (auto* controller : ObjectFinder<ShipManagementViewController>::GetAll()) {
-    if (!controller || !controller->isActiveAndEnabled()) continue;
+  for (auto* controller : unity::Instances<ShipManagementViewController>()) {
+    if (!controller || !controller->isActiveAndEnabled())
+      continue;
 
-    auto canvas = GetCanvasControllerFromComponent(controller);
-    if (canvas && canvas->Visible()) return true;
+    auto canvas = CanvasController::Of(controller);
+    if (canvas && canvas->Visible())
+      return true;
   }
   return false;
 }
 
-std::string JoinNames(const std::vector<std::string>& names)
+std::string JoinNames(const std::vector<std::vector<std::string>>& names)
 {
   std::string joined;
   for (size_t i = 0; i < names.size(); ++i) {
-    if (i != 0) joined += ", ";
-    joined += names[i];
+    if (i != 0)
+      joined += ", ";
+    joined += fmt::format("{}", fmt::join(names[i], " "));
   }
   return joined;
 }
 
 // Update ui.pinned_ships in the user's config file so pins survive a restart.
 // If/when we merge the runtime config writer we can route this through that instead of writing the file directly.
-void PersistPinnedShips(const std::vector<std::string>& names)
+void PersistPinnedShips(const std::vector<std::vector<std::string>>& names)
 {
   const auto joined = JoinNames(names);
 
   toml::table table;
   try {
-    if (std::filesystem::exists(File::Config())) {
-      table = toml::parse_file(File::Config());
+    if (std::filesystem::exists(File::Path(File::Config()))) {
+      table = toml::parse_file(File::Path(File::Config()).string());
     }
   } catch (const std::exception& error) {
     spdlog::warn("[PinnedShipClick] could not read '{}' to persist pinned ships: {}", File::Config(), error.what());
@@ -76,16 +79,11 @@ void PersistPinnedShips(const std::vector<std::string>& names)
     ui->insert_or_assign("pinned_ships", joined);
   }
 
-  Config::Save(table, File::Config(), false);
-}
-
-const MethodInfo* FindMethodInHierarchy(Il2CppClass* cls, const char* name, int argc)
-{
-  for (; cls; cls = il2cpp_class_get_parent(cls)) {
-    auto* m = il2cpp_class_get_method_from_name(cls, name, argc);
-    if (m) return m;
-  }
-  return nullptr;
+  std::ofstream file(File::Path(File::Config(), true));
+  file << table;
+  file.close();
+  if (!file)
+    spdlog::warn("[PinnedShipClick] could not persist pinned ships to '{}'", File::Config());
 }
 
 // Re-runs the pinned sort and rebuilds the dock's tile list through the
@@ -94,37 +92,28 @@ const MethodInfo* FindMethodInHierarchy(Il2CppClass* cls, const char* name, int
 // the reordered SortedIdleShips directly.
 void RefreshPinnedShipSortNow()
 {
-  for (auto* controller : ObjectFinder<ShipManagementViewController>::GetAll()) {
-    if (!controller || !controller->isActiveAndEnabled()) continue;
+  for (auto* controller : unity::Instances<ShipManagementViewController>()) {
+    if (!controller || !controller->isActiveAndEnabled())
+      continue;
 
-    auto canvas = GetCanvasControllerFromComponent(controller);
-    if (!canvas || !canvas->Visible()) continue;
+    auto canvas = CanvasController::Of(controller);
+    if (!canvas || !canvas->Visible())
+      continue;
 
     auto* context = controller->Context();
-    if (!context) continue;
+    if (!context)
+      continue;
     context->Sort();
 
-    for (auto* widget : ObjectFinder<AssignShipsWidget>::GetAll()) {
-      if (!widget || !widget->isActiveAndEnabled()) continue;
+    for (auto* widget : unity::Instances<AssignShipsWidget>()) {
+      if (!widget || !widget->isActiveAndEnabled())
+        continue;
 
       auto* list = widget->selectableList();
-      if (!list) continue;
-
-      auto* list_cls = il2cpp_object_get_class(reinterpret_cast<Il2CppObject*>(list));
-      auto* get_data = FindMethodInHierarchy(list_cls, "get_Data", 0);
-      auto* rebuild  = FindMethodInHierarchy(list_cls, "ClearAndGenerateContents", 2);
-      if (!get_data || !rebuild) continue;
-
-      Il2CppException* exc  = nullptr;
-      auto*            data = il2cpp_runtime_invoke(get_data, list, nullptr, &exc);
-      if (exc || !data) continue;
-
-      void* args[2] = {controller, data};
-      exc           = nullptr;
-      il2cpp_runtime_invoke(rebuild, list, args, &exc);
-      if (exc) {
-        spdlog::warn("[PinnedShipClick] ClearAndGenerateContents raised an exception");
-      }
+      if (!list)
+        continue;
+
+      list->Rebuild(controller);
     }
   }
 }
@@ -134,23 +123,28 @@ void RefreshPinnedShipSortNow()
 void PinShipClickOnTileClicked(FleetPlayerData* ship)
 {
   auto& cfg = Config::Get();
-  if (!cfg.installPinnedShipClickToggle) return;
-  if (!IsShiftHeld()) return;
-  if (!IsShipManagementScreenVisible()) return;
-  if (!ship) return;
+  if (!cfg.patches.pinnedshipclicktoggle)
+    return;
+  if (!IsShiftHeld())
+    return;
+  if (!IsShipManagementScreenVisible())
+    return;
+  if (!ship)
+    return;
 
-  const auto key = ShipNameMatch::NormalizeKey(ShipNameMatch::GameDisplayName(ship));
-  if (key.empty()) return; // placeholder tiles (e.g. "build ship") have no name
+  const auto key = ShipNameWords(ship->DisplayName());
+  if (key.empty())
+    return; // placeholder tiles (e.g. "build ship") have no name
 
-  auto& names = cfg.pinned_ships;
+  auto& names = cfg.ui.pinned_ships;
 
   const bool was_pinned = std::find(names.begin(), names.end(), key) != names.end();
   if (was_pinned) {
     names.erase(std::find(names.begin(), names.end(), key));
-    spdlog::info("[PinnedShipClick] unpinned ship '{}'", key);
+    spdlog::info("[PinnedShipClick] unpinned ship '{}'", fmt::join(key, " "));
   } else {
     names.push_back(key);
-    spdlog::info("[PinnedShipClick] pinned ship '{}'", key);
+    spdlog::info("[PinnedShipClick] pinned ship '{}'", fmt::join(key, " "));
   }
 
   PersistPinnedShips(names);
@@ -158,6 +152,8 @@ void PinShipClickOnTileClicked(FleetPlayerData* ship)
   RefreshPinnedShipSortNow();
 }
 
+namespace
+{
 void InstallPinnedShipClickHooks()
 {
   // The HandleOnClick detour is owned by the shared ship-tile click
@@ -168,3 +164,6 @@ void InstallPinnedShipClickHooks()
     spdlog::info("Pinned ship click: hooks installed");
   }
 }
+} // namespace
+
+const Feature kPinnedShipClick{"PinnedShipClick", &Config::Patches::pinnedshipclicktoggle, InstallPinnedShipClickHooks};
diff --git a/mods/src/patches/parts/pinned_ship_click.h b/mods/src/patches/parts/pinned_ship_click.h
index 923e42a0d..185a36acf 100644
--- a/mods/src/patches/parts/pinned_ship_click.h
+++ b/mods/src/patches/parts/pinned_ship_click.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "prime/FleetPlayerData.h"
+#include "prime/fleet.h"
 
 void PinShipClickOnTileClicked(FleetPlayerData* ship);
-void InstallPinnedShipClickHooks();
diff --git a/mods/src/patches/parts/pinned_ship_sort.cc b/mods/src/patches/parts/pinned_ship_sort.cc
deleted file mode 100644
index 0a930f53c..000000000
--- a/mods/src/patches/parts/pinned_ship_sort.cc
+++ /dev/null
@@ -1,151 +0,0 @@
-#include "config.h"
-#include "ship_name_match.h"
-
-#include <prime/FleetPlayerData.h>
-#include <prime/ShipManagementViewContext.h>
-
-#include <il2cpp/il2cpp.h>
-
-#include <spdlog/spdlog.h>
-#include <spud/detour.h>
-
-#include <algorithm>
-#include <cstdint>
-#include <vector>
-
-// Fleet management dock ship sort: hooks ShipManagementViewContext.Sort()
-// and stable-partitions cfg.pinned_ships to the front of SortedIdleShips,
-// keeping the active sort field's order within both the pinned group and
-// everyone else. Only the concrete class is hooked, not ISortedFleetsContext,
-// so HailingFrequenciesInventoryContext is unaffected. Matching is shared
-// with the instant-warp filters (ship_name_match.h). If multiple ships share
-// a pinned name, only the highest-level unclaimed one is pinned.
-
-namespace {
-
-struct ShipEntry {
-  FleetPlayerData* item;
-  std::vector<std::string> match_words; // words from the game's own display name
-  int64_t       level;
-  int64_t                  hull_id      = 0;
-  int8_t                   tech_applied = -1;
-
-  bool TechApplied()
-  {
-    if (tech_applied < 0)
-      tech_applied = item && item->HasAppliedTech() ? 1 : 0;
-    return tech_applied == 1;
-  }
-};
-
-ShipEntry BuildShipEntry(FleetPlayerData* ship)
-{
-  ShipEntry entry{ship, {}, 0};
-  if (!ship) return entry;
-
-  entry.level       = ship->Level();
-  entry.hull_id     = ship->HullId();
-  entry.match_words = ShipNameMatch::DisplayWords(ship);
-  return entry;
-}
-
-// Stable-partitions `list` (a List<FleetPlayerData>) so that ships matching
-// cfg.pinned_ships come first, while both the pinned group and everyone else
-// keep their existing relative order (i.e. whatever sort field is active).
-void ReorderPinnedShips(il2cpp::List<FleetPlayerData*>* list)
-{
-  if (!list) return;
-
-  const auto& cfg = Config::Get();
-  if (cfg.pinned_ships.empty()) return;
-
-  const auto count = list->Count();
-  if (count <= 1) return;
-  if (count > 2000) {
-    spdlog::warn("[PinnedShipSort] SortedIdleShips reported an implausible count ({}); skipping", count);
-    return;
-  }
-
-  // cfg.pinned_ships entries are already normalized (see parse_ship_filter /
-  // ShipNameMatch::NormalizeKey in config.cc); just split them into words.
-  std::vector<std::vector<std::string>> pinned_words;
-  pinned_words.reserve(cfg.pinned_ships.size());
-  for (const auto& name : cfg.pinned_ships) pinned_words.push_back(ShipNameMatch::SplitWords(name));
-
-  std::vector<ShipEntry> ships;
-  ships.reserve(count);
-  for (int32_t i = 0; i < count; ++i)
-    ships.push_back(BuildShipEntry((*list)[i]));
-
-  constexpr int    kPinnedRank   = 0;
-  constexpr int    kUnpinnedRank = 1;
-  std::vector<int> ranks(count, kUnpinnedRank);
-
-  bool any_pinned = false;
-  for (size_t p = 0; p < pinned_words.size(); ++p) {
-    if (pinned_words[p].empty()) continue;
-
-    int     best_index = -1;
-    int64_t best_level = -1;
-    for (int32_t i = 0; i < count; ++i) {
-      if (ranks[i] != kUnpinnedRank) continue; // already claimed by an earlier pinned_ships entry
-      if (!ShipNameMatch::MatchesDisplay(ships[i].match_words, pinned_words[p])) continue;
-      if (ships[i].level > best_level) {
-        best_level = ships[i].level;
-        best_index = i;
-      } else if (best_index >= 0 && ships[i].level == best_level && ships[i].hull_id == ships[best_index].hull_id
-                 && ships[i].TechApplied() && !ships[best_index].TechApplied()) {
-        best_index = i;
-      }
-    }
-
-    if (best_index >= 0) {
-      ranks[best_index] = kPinnedRank;
-      any_pinned        = true;
-    } else {
-      spdlog::warn("[PinnedShipSort] pinned_ships entry '{}' matched no idle ship (entries match the "
-                   "game's own display name for a ship that is idle in its dock)",
-                   cfg.pinned_ships[p]);
-    }
-  }
-
-  if (!any_pinned) return;
-
-  std::vector<FleetPlayerData*> items;
-  items.reserve(count);
-  for (const auto& entry : ships) items.push_back(entry.item);
-
-  std::vector<int> order(count);
-  for (int32_t i = 0; i < count; ++i) order[i] = i;
-  std::ranges::stable_sort(order, [&](int a, int b) { return ranks[a] < ranks[b]; });
-
-  bool changed = false;
-  for (int32_t i = 0; i < count; ++i) {
-    if (order[i] != i) {
-      changed = true;
-      break;
-    }
-  }
-  if (!changed) return;
-
-  // SortedIdleShips is a List<T>, which always has Clear and Add; the rewrite cannot stop halfway.
-  list->Call<"Clear">();
-  for (int32_t i = 0; i < count; ++i)
-    list->Add(items[order[i]]);
-}
-
-void ShipManagementViewContext_Sort_Hook(auto original, ShipManagementViewContext* _this)
-{
-  original(_this);
-  ReorderPinnedShips(_this->SortedIdleShips());
-}
-
-} // namespace
-
-void InstallPinnedShipSortHooks()
-{
-  if (auto m = ShipManagementViewContext::Class::Method("Sort", 0)) {
-    SPUD_STATIC_DETOUR(m.Pointer(), ShipManagementViewContext_Sort_Hook);
-    spdlog::info("Pinned ship sort: hooks installed");
-  }
-}
diff --git a/mods/src/patches/parts/queue_address_guard.cc b/mods/src/patches/parts/queue_address_guard.cc
index 47a806fee..5cfaec4eb 100644
--- a/mods/src/patches/parts/queue_address_guard.cc
+++ b/mods/src/patches/parts/queue_address_guard.cc
@@ -1,20 +1,21 @@
+#include "patches/patches.h"
 #include "patches/queue_address_guard_policy.h"
+#include "prime/queues.h"
 #include <array>
 #include <atomic>
 #include <config.h>
 #include <cstring>
-#include <il2cpp/il2cpp_helper.h>
-#include <il2cpp/method_contract.h>
+#include <il2cpp/hook.h>
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
+
+using namespace queue_bindings::address;
 
 namespace
 {
 using Object = Il2CppObject;
 using Id     = std::int64_t;
-std::atomic_bool  ready{false};
-Il2CppClass *     managerClass{}, *queueClass{}, *actionClass{}, *playerClass{}, *deployedClass{};
-FieldInfo *       queuesField{}, *fleetField{}, *actionsField{}, *targetField{}, *idField{}, *indexField{};
+std::atomic_bool ready{false};
+
 thread_local bool playerStateEvent{};
 struct AddressContext {
   Object* player{};
@@ -26,116 +27,9 @@ struct AddressContext {
 thread_local AddressContext* context{};
 
 bool Enabled()
-{ return ready.load() && Config::Get().kirshara_fixes && Config::Get().queue_enabled; }
-
-bool Is(Object* object, Il2CppClass* cls)
-{ return object && il2cpp_object_get_class(object) == cls; }
-
-FieldInfo* Field(Il2CppClass* cls, const char* name, Il2CppTypeEnum type)
-{
-  auto* field = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
-  return field && field->type && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC) && field->offset >= sizeof(Object)
-                 && field->type->type == type
-             ? field
-             : nullptr;
-}
-template <typename T> T Read(Object* object, FieldInfo* field)
-{
-  T value{};
-  if (object && field)
-    il2cpp_field_get_value(object, field, &value);
-  return value;
-}
-Object* Reference(Object* object, const char* name)
-{
-  auto* cls   = object ? il2cpp_object_get_class(object) : nullptr;
-  auto* field = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
-  auto* type  = field && field->type ? il2cpp_class_from_type(field->type) : nullptr;
-  return type && !il2cpp_class_is_valuetype(type) && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)
-                 && field->offset >= sizeof(Object)
-             ? Read<Object*>(object, field)
-             : nullptr;
-}
-int Enum(Object* object, const char* name)
-{
-  auto* cls   = object ? il2cpp_object_get_class(object) : nullptr;
-  auto* field = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
-  auto* type  = field && field->type ? il2cpp_class_from_type(field->type) : nullptr;
-  auto* base  = type && il2cpp_class_is_enum(type) ? il2cpp_class_enum_basetype(type) : nullptr;
-  return base && base->type == IL2CPP_TYPE_I4 && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)
-                 && field->offset >= sizeof(Object)
-             ? Read<int>(object, field)
-             : -1;
-}
-int State(Object* object, const char* name)
-{
-  auto* cls       = object ? il2cpp_object_get_class(object) : nullptr;
-  auto* field     = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
-  auto* container = field && field->type ? il2cpp_class_from_type(field->type) : nullptr;
-  if (!container || !il2cpp_class_is_valuetype(container) || field->offset < sizeof(Object)
-      || (field->type->attrs & FIELD_ATTRIBUTE_STATIC))
-    return -1;
-  uint32_t  alignment{};
-  const int size   = il2cpp_class_value_size(container, &alignment);
-  auto*     inner  = il2cpp_class_get_field_from_name(container, "_currentState");
-  auto*     type   = inner && inner->type ? il2cpp_class_from_type(inner->type) : nullptr;
-  auto*     base   = type && il2cpp_class_is_enum(type) ? il2cpp_class_enum_basetype(type) : nullptr;
-  const int offset = inner ? inner->offset - static_cast<int>(sizeof(Object)) : -1;
-  if (!base || base->type != IL2CPP_TYPE_I4 || (inner->type->attrs & FIELD_ATTRIBUTE_STATIC) || offset < 0
-      || offset + sizeof(int) > size)
-    return -1;
-  int value{};
-  std::memcpy(&value, reinterpret_cast<const char*>(object) + field->offset + offset, sizeof(value));
-  return value;
-}
-queue_address_guard::Address Address(Object* object)
-{
-  auto* cls      = object ? il2cpp_object_get_class(object) : nullptr;
-  auto* galaxy   = Field(cls, "galaxy_", IL2CPP_TYPE_I8);
-  auto* system   = Field(cls, "system_", IL2CPP_TYPE_I8);
-  auto* planet   = Field(cls, "planet_", IL2CPP_TYPE_I8);
-  auto* instance = Field(cls, "instance_", IL2CPP_TYPE_I4);
-  if (!galaxy || !system || !planet || !instance)
-    return {};
-  queue_address_guard::Address value{true, Read<Id>(object, galaxy), Read<Id>(object, system), Read<Id>(object, planet),
-                                     Read<int>(object, instance)};
-  value.valid = value.galaxy >= 0 && value.system > 0 && value.planet >= 0 && value.instance >= 0;
-  return value;
-}
-
-// Existing queue snapshots use fixed Windows offsets. This guard also runs on macOS
-// and resolves metadata instead; unknown or incomplete storage retains native behavior.
-bool OwnsNonemptyQueue(Object* manager, Object* player, Id fleet)
-{
-  auto*     array = Read<Il2CppArray*>(manager, queuesField);
-  const int index = Read<int>(player, indexField);
-  if (!array || !fleet || index < 0 || il2cpp_array_length(array) > 64
-      || static_cast<unsigned>(index) >= il2cpp_array_length(array)
-      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Object*>(array))) != queueClass)
-    return false;
-  auto* queue = static_cast<Object*>(reinterpret_cast<Il2CppArraySize*>(array)->vector[index]);
-  if (!Is(queue, queueClass) || Read<Id>(queue, fleetField) != fleet)
-    return false;
-  auto* list    = Read<Object*>(queue, actionsField);
-  auto* cls     = list ? il2cpp_object_get_class(list) : nullptr;
-  auto* size    = Field(cls, "_size", IL2CPP_TYPE_I4);
-  auto* storage = Field(cls, "_items", IL2CPP_TYPE_SZARRAY);
-  if (!size || !storage)
-    return false;
-  const int count = Read<int>(list, size);
-  auto*     items = Read<Il2CppArray*>(list, storage);
-  if (count <= 0 || count > 128 || !items || il2cpp_array_length(items) < static_cast<unsigned>(count)
-      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Object*>(items))) != actionClass)
-    return false;
-  for (int i = 0; i < count; ++i) {
-    auto* action = static_cast<Object*>(reinterpret_cast<Il2CppArraySize*>(items)->vector[i]);
-    if (!Is(action, actionClass) || !Read<Id>(action, targetField))
-      return false;
-  }
-  return true;
-}
+{ return ready.load() && Config::Get().control.kirshara_fixes && Config::Get().control.queue_enabled; }
 
-void PlayerStateChange(auto original, Object* manager, Object* fleets)
+void ActionQueueManager_OnPlayerFleetStateChangedEventHandler_Hook(auto original, Object* manager, Object* fleets)
 {
   if (!Enabled()) {
     original(manager, fleets);
@@ -150,7 +44,8 @@ void PlayerStateChange(auto original, Object* manager, Object* fleets)
   } event;
   original(manager, fleets);
 }
-bool AddressMismatch(auto original, Object* manager, Object* player)
+bool ActionQueueManager_DoesFleetQueueContainMismatchedAddressTargets_Hook(auto original, Object* manager,
+                                                                           Object* player)
 {
   if (!Enabled() || !playerStateEvent || !Is(manager, managerClass) || !Is(player, playerClass))
     return original(manager, player);
@@ -167,26 +62,19 @@ bool AddressMismatch(auto original, Object* manager, Object* player)
   } scope(evidence);
   return original(manager, player);
 }
-Object* PlayerAddress(auto original, Object* player)
+Object* FleetPlayerData_get_Address_Hook(auto original, Object* player)
 {
   auto* result = original(player);
   auto* e      = context;
   if (!Enabled() || !e || player != e->player || !Is(e->ownDeployment, deployedClass) || !Is(e->target, deployedClass))
     return result;
-  auto* own    = e->ownDeployment;
-  auto* cls    = il2cpp_object_get_class(own);
-  auto* local  = Field(cls, "_localPlayerFleet", IL2CPP_TYPE_BOOLEAN);
-  auto* recall = Field(cls, "<IsPlanningRecallCourse>k__BackingField", IL2CPP_TYPE_BOOLEAN);
-  auto* model  = Reference(own, "_deploymentFleet");
-  auto* id     = model ? Field(il2cpp_object_get_class(model), "fleetId_", IL2CPP_TYPE_I8) : nullptr;
-  if (model && !id)
-    id = Field(il2cpp_object_get_class(model), "<FleetId>k__BackingField", IL2CPP_TYPE_I8);
+  auto*                               own     = e->ownDeployment;
   auto*                               correct = Reference(own, "_address");
   const queue_address_guard::Evidence proof{true,
                                             playerStateEvent,
                                             true,
-                                            local && Read<bool>(own, local) && id && Read<Id>(model, id) == e->fleet,
-                                            !recall || Read<bool>(own, recall),
+                                            IsLocalDeployment(own, e->fleet),
+                                            PlanningRecall(own),
                                             State(player, "_fleetStateContainer"),
                                             State(own, "_stateContainer"),
                                             Enum(own, "<RemovalReason>k__BackingField"),
@@ -197,7 +85,7 @@ Object* PlayerAddress(auto original, Object* player)
   // No fleet fields, queues, or previous-frame address caches are changed.
   return queue_address_guard::UseDeployedAddress(proof) ? correct : result;
 }
-Object* LookupTarget(auto original, Object* service, Id target)
+Object* DeploymentService_GetDeployedFleet_Hook(auto original, Object* service, Id target)
 {
   auto* result = original(service, target);
   if (Enabled() && context) {
@@ -212,49 +100,30 @@ Object* LookupTarget(auto original, Object* service, Id target)
 }
 } // namespace
 
+namespace
+{
 void InstallQueueAddressGuard()
 {
-  managerClass = il2cpp_get_class_helper("Assembly-CSharp", "Prime.ActionQueue", "ActionQueueManager").get_cls();
-  queueClass   = il2cpp_get_class_helper("Assembly-CSharp", "Prime.ActionQueue", "ActionQueueInstance").get_cls();
-  actionClass  = il2cpp_get_class_helper("Assembly-CSharp", "Prime.ActionQueue", "QueueableAction").get_cls();
-  playerClass =
-      il2cpp_get_class_helper("Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetPlayerData").get_cls();
-  deployedClass =
-      il2cpp_get_class_helper("Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetDeployedData")
-          .get_cls();
-  auto* serviceClass =
-      il2cpp_get_class_helper("Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "DeploymentService")
-          .get_cls();
-  queuesField  = Field(managerClass, "_battleQueue", IL2CPP_TYPE_SZARRAY);
-  fleetField   = Field(queueClass, "<PlayerFleetId>k__BackingField", IL2CPP_TYPE_I8);
-  actionsField = Field(queueClass, "_actionQueue", IL2CPP_TYPE_GENERICINST);
-  targetField  = Field(actionClass, "<FleetId>k__BackingField", IL2CPP_TYPE_I8);
-  idField      = Field(playerClass, "<ID>k__BackingField", IL2CPP_TYPE_I8);
-  indexField   = Field(playerClass, "<Index>k__BackingField", IL2CPP_TYPE_I4);
-  using method_contract::Pointer;
-  using method_contract::Resolve;
-  const std::array methods{
-      Resolve(managerClass, "OnPlayerFleetStateChangedEventHandler", false, "System.Void",
-              {"System.Collections.Generic.List<Digit.PrimeServer.Models.FleetPlayerData>"}),
-      Resolve(managerClass, "DoesFleetQueueContainMismatchedAddressTargets", false, "System.Boolean",
-              {"Digit.PrimeServer.Models.FleetPlayerData"}),
-      Resolve(playerClass, "get_Address", false, "Digit.PrimeServer.Models.NodeAddress", {}),
-      Resolve(serviceClass, "GetDeployedFleet", false, "Digit.PrimeServer.Models.FleetDeployedData", {"System.Int64"})};
-  bool valid = managerClass && queueClass && actionClass && playerClass && deployedClass && serviceClass && queuesField
-               && fleetField && actionsField && targetField && idField && indexField;
-  for (unsigned i = 0; i < methods.size(); ++i) {
-    valid = valid && methods[i] && !methods[i]->has_full_generic_sharing_signature;
-    for (unsigned j = 0; j < i; ++j)
-      valid = valid && Pointer(methods[i]) != Pointer(methods[j]);
-  }
-  if (!valid) {
-    spdlog::warn("[QueueAddressGuard] native method/field contract unavailable; retaining native behavior");
+  if (!ResolveBindings())
     return;
-  }
-  const bool a = SPUD_STATIC_DETOUR(Pointer(methods[0]), PlayerStateChange) != nullptr;
-  const bool b = SPUD_STATIC_DETOUR(Pointer(methods[1]), AddressMismatch) != nullptr;
-  const bool c = SPUD_STATIC_DETOUR(Pointer(methods[2]), PlayerAddress) != nullptr;
-  const bool d = SPUD_STATIC_DETOUR(Pointer(methods[3]), LookupTarget) != nullptr;
+  const bool a = IL2CPP_DETOUR(il2cpp::contract::Pointer(methods[0]),
+                               ActionQueueManager_OnPlayerFleetStateChangedEventHandler_Hook,
+                               "ActionQueueManager_OnPlayerFleetStateChangedEventHandler_Hook")
+                 != nullptr;
+  const bool b = IL2CPP_DETOUR(il2cpp::contract::Pointer(methods[1]),
+                               ActionQueueManager_DoesFleetQueueContainMismatchedAddressTargets_Hook,
+                               "ActionQueueManager_DoesFleetQueueContainMismatchedAddressTargets_Hook")
+                 != nullptr;
+  const bool c = IL2CPP_DETOUR(il2cpp::contract::Pointer(methods[2]), FleetPlayerData_get_Address_Hook,
+                               "FleetPlayerData_get_Address_Hook")
+                 != nullptr;
+  const bool d = IL2CPP_DETOUR(il2cpp::contract::Pointer(methods[3]), DeploymentService_GetDeployedFleet_Hook,
+                               "DeploymentService_GetDeployedFleet_Hook")
+                 != nullptr;
   ready.store(a && b && c && d);
   spdlog::info("[QueueAddressGuard] ready={}", ready.load());
 }
+} // namespace
+
+const Feature kQueueAddressGuard{"QueueAddressGuard", &Config::Patches::queueaddressguardhooks,
+                                 InstallQueueAddressGuard};
diff --git a/mods/src/patches/parts/reveal_confirmation.cc b/mods/src/patches/parts/reveal_confirmation.cc
index 75a8dfdbd..34b1b9dd7 100644
--- a/mods/src/patches/parts/reveal_confirmation.cc
+++ b/mods/src/patches/parts/reveal_confirmation.cc
@@ -1,13 +1,12 @@
 #include "config.h"
-#include "errormsg.h"
+#include "patches/patches.h"
 
-#include <il2cpp/il2cpp_helper.h>
-#include <il2cpp/method_contract.h>
+#include <il2cpp/hook.h>
 
-#include <prime/ActivatedAbilityManager.h>
+#include "prime/fleet.h"
+#include "prime/ui.h"
 
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
 
 namespace
 {
@@ -23,30 +22,13 @@ bool IsExcelsiorDecloakAbility(int64_t abilityId)
   return manager->GetActivatedAbilityType(abilityId) == ActivatedAbilityManager::RevealHostileVgerAbilityType;
 }
 
-bool InvokeActivationAction(Il2CppDelegate* action)
-{
-  if (action == nullptr || action->method == nullptr) {
-    return false;
-  }
-
-  Il2CppException* exception = nullptr;
-  il2cpp_runtime_invoke(action->method, action->target, nullptr, &exception);
-
-  if (exception != nullptr) {
-    spdlog::warn("RevealConfirmation: failed to invoke the activation action");
-    return false;
-  }
-
-  return true;
-}
-
 // Digit.Client.UI.MessageUtility.ShowFreeAbilityConfirmationPopup(long abilityId, TimeSpan cooldown,
 // Action action). TimeSpan is a single 8-byte value type, so it occupies one argument slot.
 void MessageUtility_ShowFreeAbilityConfirmationPopup_Hook(auto original, int64_t abilityId, int64_t cooldownTicks,
                                                           Il2CppDelegate* action)
 {
-  if (Config::Get().auto_confirm_reveal_ability && IsExcelsiorDecloakAbility(abilityId)
-      && InvokeActivationAction(action)) {
+  if (Config::Get().ui.auto_confirm_reveal_ability && IsExcelsiorDecloakAbility(abilityId)
+      && MessageUtility::InvokeActivationAction(action)) {
     spdlog::debug("RevealConfirmation: auto-confirmed the Excelsior's decloaking ability {}", abilityId);
     return;
   }
@@ -55,23 +37,13 @@ void MessageUtility_ShowFreeAbilityConfirmationPopup_Hook(auto original, int64_t
 }
 } // namespace
 
+namespace
+{
 void InstallRevealConfirmationHooks()
 {
-  auto message_utility_helper = il2cpp_get_class_helper("Assembly-CSharp", "Digit.Client.UI", "MessageUtility");
-  if (!message_utility_helper.isValidHelper()) {
-    spdlog::warn("Missing class {}.{}", "Digit.Client.UI", "MessageUtility");
-    return;
-  }
-
-  const auto* show =
-      method_contract::Resolve(message_utility_helper.get_cls(), "ShowFreeAbilityConfirmationPopup", true,
-                               "System.Void", {"System.Int64", "System.TimeSpan", "System.Action"});
-  if (!show || !show->methodPointer || show->has_full_generic_sharing_signature) {
-    spdlog::warn("Missing method {}.{}", "MessageUtility", "ShowFreeAbilityConfirmationPopup");
-    return;
-  }
-
-  if (!SPUD_STATIC_DETOUR(show->methodPointer, MessageUtility_ShowFreeAbilityConfirmationPopup_Hook)) {
-    spdlog::warn("RevealConfirmation: hook installation failed; the confirmation popup stays untouched");
-  }
+  IL2CPP_DETOUR(MessageUtility::RevealConfirmationTarget(), MessageUtility_ShowFreeAbilityConfirmationPopup_Hook,
+                "MessageUtility.ShowFreeAbilityConfirmationPopup");
 }
+} // namespace
+
+const Feature kRevealConfirm{"RevealConfirm", &Config::Patches::revealconfirmhooks, InstallRevealConfirmationHooks};
diff --git a/mods/src/patches/parts/screens.cc b/mods/src/patches/parts/screens.cc
new file mode 100644
index 000000000..2e00fe3ea
--- /dev/null
+++ b/mods/src/patches/parts/screens.cc
@@ -0,0 +1,344 @@
+// Shortcuts that open game screens, press the buttons on them, and step through them: the show_* navigation
+// shortcuts, Ship Swap and the officer swap and preset buttons, the arrow keys on docks, artifacts and selectors, and
+// focusing the search box.
+
+#include "config.h"
+#include "patches/patches.h"
+#include "patches/shortcuts.h"
+
+#include "prime/Hub.h"
+#include "prime/fleet.h"
+#include "prime/inventory.h"
+#include "prime/navigation.h"
+#include "prime/officers.h"
+#include "prime/ui.h"
+
+#include <il2cpp/il2cpp.h>
+#include <spdlog/spdlog.h>
+#include <unity/tracker.h>
+
+namespace
+{
+// Ship Swap and Officer Swap live on the Manage Ships screen, and Officer Presets on the officer assignment screen
+// that Officer Swap opens. Their shortcuts open those screens first, then press the button once it exists. 300
+// frames is a few seconds at the game's frame rate.
+constexpr int kButtonWaitFrames = 300;
+
+struct Waits {
+  int  ship_swap         = 0;
+  int  officer_swap      = 0;
+  int  officer_presets   = 0;
+  bool assignment_opened = false;
+} waits;
+
+// Runs one of the game's own shortcut handlers. A handler missing from this client is reported once by the binding
+// layer and does nothing.
+template <il2cpp::Name Action> void Native()
+{
+  if (auto* manager = ShortcutsManager::Instance())
+    manager->Run<Action>();
+  else
+    spdlog::warn("[Hotkeys] native {} shortcut is unavailable", Action.View());
+}
+
+template <SectionID Section> void Goto()
+{ Hub::GotoSection(Section); }
+
+// Galaxy and system views keep their state in section storage; reuse it so the camera returns where it was.
+template <SectionID Section> void GotoNavigation()
+{
+  auto* manager = Hub::Sections();
+  auto* storage = manager ? manager->sectionStorage() : nullptr;
+  if (auto* state = storage ? storage->GetState(Section) : nullptr)
+    Hub::GotoSection(Section, state);
+  else
+    NavigationSectionManager::ChangeNavigationSection(Section);
+}
+
+void ShowBookmarks()
+{
+  if (auto* bookmarks = BookmarksManager::Instance())
+    bookmarks->ViewBookmarks();
+  else
+    Hub::GotoSection(SectionID::Bookmarks_Main);
+}
+
+void ShowCoordinateSearch()
+{
+  if (auto* bookmarks = BookmarksManager::Instance())
+    return bookmarks->ViewCoordinateSearch();
+  spdlog::warn("[ShowLookup] BookmarksManager instance not available, falling back to main bookmarks");
+  Hub::GotoSection(SectionID::Bookmarks_Main);
+}
+
+void ShowHaven()
+{ PlanetaryBaseManager::ViewOwnHaven(); }
+
+// Presses the button `pick` returns on the first visible, active Controller.
+template <typename Controller> bool PressButton(unity::Button* (*pick)(Controller*))
+{
+  for (auto* controller : unity::Instances<Controller>()) {
+    auto* button = controller && CanvasController::Shows(controller) && controller->isActiveAndEnabled()
+                       ? pick(controller)
+                       : nullptr;
+    if (button) {
+      button->Press();
+      return true;
+    }
+  }
+  return false;
+}
+
+bool PressShipSwapButton()
+{
+  return PressButton<ShipManagementScreenStateViewController>(
+      [](ShipManagementScreenStateViewController* controller) { return controller->swapShipButton(); });
+}
+
+bool PressOfficerSwapButton()
+{
+  return PressButton<ShipManagementScreenStateViewController>(
+      [](ShipManagementScreenStateViewController* controller) { return controller->officerIconButton(); });
+}
+
+bool PressOfficerPresetsButton()
+{
+  return PressButton<OfficerAssignmentViewController>(
+      [](OfficerAssignmentViewController* controller) -> unity::Button* {
+        auto* widget = controller->officerPresetsButton();
+        return widget ? widget->TheButton() : nullptr;
+      });
+}
+
+void OpenManageShips()
+{
+  auto* fleet_bar = unity::Newest<FleetBarViewController>();
+  if (auto* fleet = fleet_bar ? fleet_bar->SelectedFleet() : nullptr)
+    fleet_bar->fleetPanelController()->RequestAction(fleet, ActionType::Manage, 0, ActionBehaviour::Default);
+}
+
+// Opens Manage Ships for the selected fleet, for a button that is only there. False, with a warning, without one.
+bool OpenManageShipsFor(const char* what)
+{
+  auto* fleet_bar = unity::Newest<FleetBarViewController>();
+  if (!fleet_bar || !fleet_bar->SelectedFleet()) {
+    spdlog::warn("[Hotkeys] unable to open Manage Ships for {}", what);
+    return false;
+  }
+  OpenManageShips();
+  return true;
+}
+
+void ShowShipSwap()
+{
+  if (!PressShipSwapButton() && OpenManageShipsFor("Ship Swap"))
+    waits.ship_swap = kButtonWaitFrames;
+}
+
+void ShowOfficerSwap()
+{
+  if (!PressOfficerSwapButton() && OpenManageShipsFor("Officer Swap"))
+    waits.officer_swap = kButtonWaitFrames;
+}
+
+void ShowOfficerPresets()
+{
+  if (PressOfficerPresetsButton())
+    return;
+  waits.assignment_opened = PressOfficerSwapButton();
+  if (waits.assignment_opened || OpenManageShipsFor("Officer Presets"))
+    waits.officer_presets = kButtonWaitFrames;
+}
+
+struct ScreenShortcut {
+  Action shortcut;
+  void (*run)();
+  // Opening Manage Ships lets the game see the key too.
+  bool consumes = true;
+};
+
+// Checked in order; the first pressed one runs.
+constexpr ScreenShortcut kScreens[] = {
+    {Action::kShowQTrials, Goto<SectionID::ChallengeSelection>},
+    {Action::kShowBookmarks, ShowBookmarks},
+    {Action::kShowLookup, ShowCoordinateSearch},
+    {Action::kShowRefinery, Goto<SectionID::Shop_Refining_List>},
+    {Action::kShowFactions, Goto<SectionID::Shop_MainFactions>},
+    {Action::kShowStationExterior, Goto<SectionID::Starbase_Exterior>},
+    {Action::kNativeShortcutGalaxy, Native<"OnGalaxyAction">},
+    {Action::kShowGalaxy, GotoNavigation<SectionID::Navigation_Galaxy>},
+    {Action::kShowStationInterior, Goto<SectionID::Starbase_Interior>},
+    {Action::kShowHaven, ShowHaven},
+    {Action::kShowSystem, GotoNavigation<SectionID::Navigation_System>},
+    {Action::kShowArtifacts, Goto<SectionID::ArtifactHall_Inventory>},
+    {Action::kShowShipConstruction, Native<"OnShipsAction">},
+    {Action::kShowOfficerSwap, ShowOfficerSwap},
+    {Action::kShowShipSwap, ShowShipSwap},
+    {Action::kShowShields, Native<"OnPeaceShieldAction">},
+    {Action::kShowBattlelogs, Native<"OnInboxAction">},
+    {Action::kShowInventory, Goto<SectionID::InventoryList>},
+    {Action::kShowMissions, Goto<SectionID::Missions_AcceptedList>},
+    {Action::kShowResearch, Goto<SectionID::Research_LandingPage>},
+    {Action::kShowScrapYard, Goto<SectionID::ShipScrapping_List>},
+    {Action::kShowOfficers, Goto<SectionID::OfficerInventory>},
+    {Action::kShowOfficerPresets, ShowOfficerPresets},
+    // TODO: opens the first fleet commander (Spock), not the selected fleet's.
+    {Action::kShowCommander, Goto<SectionID::FleetCommander_Management>},
+    {Action::kShowAwayTeam, Goto<SectionID::Missions_AwayTeamsList>},
+    {Action::kNativeShortcutEvents, Native<"OnEventsAction">},
+    {Action::kShowEvents, Goto<SectionID::Tournament_Group_Selection>},
+    {Action::kShowExoComp, Goto<SectionID::Consumables>},
+    {Action::kShowDaily, Goto<SectionID::Missions_DailyGoals>},
+    {Action::kShowGifts, Goto<SectionID::Shop_List>},
+    {Action::kShowAlliance, Goto<SectionID::Alliance_Main>},
+    {Action::kShowAllianceHelp, Goto<SectionID::Alliance_Help>},
+    {Action::kShowAllianceArmada, Goto<SectionID::Alliance_Armadas>},
+    {Action::kShowSettings, Goto<SectionID::GameSettings>},
+    {Action::kShowShips, OpenManageShips, false},
+};
+
+// Left and right step through docks, ship lists, artifacts and officer pages on the screens that have them,
+// before they pan the camera. Returns true when something moved.
+bool StepScreen(bool left)
+{
+  const auto& config = Config::Get();
+
+  if (config.ui.arrow_keys_to_select_ship && Hub::CurrentSection() == SectionID::ShipManagement_Details) {
+    bool moved = false;
+    for (auto* controller : unity::Instances<ShipManagementViewController>()) {
+      auto* context = controller && controller->isActiveAndEnabled() && CanvasController::Shows(controller)
+                          ? controller->Context()
+                          : nullptr;
+      if (!context)
+        continue;
+      const int32_t count = context->ListCount();
+      const int32_t next  = context->CurrentIndex() + (left ? -1 : 1);
+      if (count <= 1 || context->CurrentIndex() < 0 || next < 0 || next >= count)
+        continue;
+      context->SetLastMovementWasToIncrement(!left);
+      context->SetCurrentIndex(next);
+      moved = true;
+    }
+    if (moved)
+      return true;
+  }
+
+  if (config.ui.arrow_keys_to_select_ship) {
+    bool moved = false;
+    for (auto* widget : unity::Instances<AssignShipsWidget>()) {
+      auto* list = widget && CanvasController::Shows(widget) && widget->isActiveAndEnabled() ? widget->selectableList()
+                                                                                             : nullptr;
+      if (!list || list->Count() <= 0)
+        continue;
+      // Skip empty dock slots.
+      const int32_t count = list->Count();
+      int32_t       index = list->SelectedIndex();
+      do
+        index += left ? -1 : 1;
+      while (index >= 0 && index < count
+             && !(list->DataItem(index) && static_cast<FleetPlayerData*>(list->DataItem(index))->HasShip()));
+      if (index < 0 || index >= count)
+        continue;
+      list->RequestSelect(index);
+      moved = true;
+    }
+    if (moved)
+      return true;
+  }
+
+  bool moved = false;
+  for (auto* controller : unity::Instances<ArtifactHallDetailsViewController>()) {
+    if (!controller || !controller->isActiveAndEnabled())
+      continue;
+    left ? controller->PressLeftArrow() : controller->PressRightArrow();
+    moved = true;
+  }
+  if (moved)
+    return true;
+
+  for (auto* selector : unity::Instances<ElementSelectorViewController>()) {
+    if (!selector || !selector->isActiveAndEnabled())
+      continue;
+    left ? selector->PressDecrement() : selector->PressIncrement();
+    moved = true;
+  }
+  return moved;
+}
+
+// Focuses the search box of whichever inventory, officer or ship list is on screen.
+bool FocusSearchBox()
+{
+  const auto focus = [](auto* owner) {
+    auto* field = owner ? owner->inputField() : nullptr;
+    if (!field || !CanvasController::Shows(owner) || !owner->isActiveAndEnabled() || !field->isActiveAndEnabled())
+      return false;
+    field->Focus();
+    return true;
+  };
+  // InventoryListViewController also covers the officer roster and the other inventory screens.
+  for (auto* controller : unity::Instances<InventoryListViewController>())
+    if (focus(controller))
+      return true;
+  for (auto* controller : unity::Instances<OfficerAssignmentViewController>())
+    if (focus(controller))
+      return true;
+  for (auto* widget : unity::Instances<AssignShipsWidget>())
+    if (focus(widget))
+      return true;
+  return false;
+}
+} // namespace
+
+bool PressAwaitedButton()
+{
+  if (waits.officer_presets > 0) {
+    if (PressOfficerPresetsButton()) {
+      waits.officer_presets   = 0;
+      waits.assignment_opened = false;
+      return true;
+    }
+    // Manage Ships is up but officer assignment not yet: open it on the way.
+    if (!waits.assignment_opened && PressOfficerSwapButton())
+      waits.assignment_opened = true;
+    if (--waits.officer_presets == 0) {
+      waits.assignment_opened = false;
+      spdlog::warn("[Hotkeys] timed out waiting for the Officer Presets button");
+    }
+  }
+
+  if (waits.officer_swap > 0) {
+    if (PressOfficerSwapButton()) {
+      waits.officer_swap = 0;
+      return true;
+    }
+    if (--waits.officer_swap == 0)
+      spdlog::warn("[Hotkeys] timed out waiting for the Officer Swap button");
+  }
+
+  if (waits.ship_swap > 0) {
+    if (PressShipSwapButton()) {
+      waits.ship_swap = 0;
+      return true;
+    }
+    if (--waits.ship_swap == 0)
+      spdlog::warn("[Hotkeys] timed out waiting for the Ship Swap button");
+  }
+  return false;
+}
+
+bool ScreenShortcuts()
+{
+  if (Shortcut::IsDown(Action::kMoveLeft) && StepScreen(true))
+    return true;
+  if (Shortcut::IsDown(Action::kMoveRight) && StepScreen(false))
+    return true;
+  if (Config::Get().ui.focus_search && Shortcut::IsDown(Action::kFocusSearch) && FocusSearchBox())
+    return true;
+  for (const auto& screen : kScreens) {
+    if (Shortcut::IsDown(screen.shortcut)) {
+      screen.run();
+      return screen.consumes;
+    }
+  }
+  return false;
+}
diff --git a/mods/src/patches/parts/ship_tile_click.cc b/mods/src/patches/parts/ship_tile_click.cc
index 21904d555..ca1643305 100644
--- a/mods/src/patches/parts/ship_tile_click.cc
+++ b/mods/src/patches/parts/ship_tile_click.cc
@@ -1,28 +1,32 @@
 #include "ship_tile_click.h"
 
 #include "config.h"
-#include "errormsg.h"
 
 #include "double_click_assign_ship.h"
 #include "pinned_ship_click.h"
-#include "prime/ShipTileWidget.h"
+#include "prime/fleet.h"
 
 #include <il2cpp/il2cpp.h>
 
+#include <il2cpp/hook.h>
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
+#include <unity/input.h>
 
-namespace {
+namespace
+{
 
 void ShipTileWidget_HandleOnClick_Hook(auto original, ShipTileWidget* _this)
 {
   original(_this);
+  unity::Key::Poll();
 
   auto& cfg = Config::Get();
-  if (!cfg.double_click_to_assign_ship && !cfg.installPinnedShipClickToggle) return;
+  if (!cfg.ui.double_click_to_assign_ship && !cfg.patches.pinnedshipclicktoggle)
+    return;
 
   auto* ship = _this ? _this->Context() : nullptr;
-  if (!ship) return;
+  if (!ship)
+    return;
 
   PinShipClickOnTileClicked(ship);
   DoubleClickOnShipTileClicked(ship);
@@ -30,7 +34,8 @@ void ShipTileWidget_HandleOnClick_Hook(auto original, ShipTileWidget* _this)
 
 } // namespace
 
-namespace ship_tile_click {
+namespace ship_tile_click
+{
 
 bool TryInstallHook()
 {
@@ -41,10 +46,9 @@ bool TryInstallHook()
 
   auto method = ShipTileWidget::Class::Method("HandleOnClick", 0);
   if (!method) {
-    spdlog::warn("Missing method {}.{}", "ShipTileWidget", "HandleOnClick");
     return false;
   }
-  installed = SPUD_STATIC_DETOUR(method.Pointer(), ShipTileWidget_HandleOnClick_Hook);
+  installed = IL2CPP_HOOK(method, ShipTileWidget_HandleOnClick_Hook);
   if (installed) {
     spdlog::info("Ship tile click dispatcher: hooks installed");
   }
diff --git a/mods/src/patches/parts/shortcut_hints.cc b/mods/src/patches/parts/shortcut_hints.cc
new file mode 100644
index 000000000..87e75726e
--- /dev/null
+++ b/mods/src/patches/parts/shortcut_hints.cc
@@ -0,0 +1,183 @@
+// The game's keybind badges, relabelled with the mod's shortcuts. The game shows a badge per input action when
+// its show_keybindings action is toggled; with mod hotkeys on, each badge shows the first binding of the mod
+// action that replaces it.
+
+#include "config.h"
+#include "patches/patches.h"
+#include "patches/ship_shortcut_hint.h"
+#include "patches/shortcuts.h"
+#include "prime/fleet.h"
+#include "str_utils.h"
+#include <unity/tracker.h>
+
+#include "prime/ui.h"
+
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
+#include <spdlog/spdlog.h>
+
+#include <array>
+#include <string_view>
+
+namespace
+{
+struct NativeAction {
+  std::string_view name;
+  Action           primary;
+  Action           fallback = Action::kCount;
+};
+
+// The game's input action names and the mod actions that replace them.
+constexpr auto kNativeActions = std::to_array<NativeAction>({
+    {"interior_view", Action::kShowStationInterior},
+    {"exterior_view", Action::kShowStationExterior},
+    {"system_view", Action::kShowSystem},
+    {"galaxy_view", Action::kShowGalaxy},
+    {"events", Action::kShowEvents},
+    {"ship_a", Action::kSelectShip1},
+    {"ship_b", Action::kSelectShip2},
+    {"ship_c", Action::kSelectShip3},
+    {"ship_d", Action::kSelectShip4},
+    {"ship_e", Action::kSelectShip5},
+    {"ship_f", Action::kSelectShip6},
+    {"ship_g", Action::kSelectShip7},
+    {"ship_h", Action::kSelectShip8},
+    {"alliance", Action::kShowAlliance},
+    {"chat", Action::kShowChat},
+    {"side_chat", Action::kShowChatSide1, Action::kShowChatSide2},
+    {"away_teams", Action::kShowAwayTeam},
+    {"missions", Action::kShowMissions},
+    {"daily_goals", Action::kShowDaily},
+    {"ship_locate", Action::kSelectCurrent},
+    {"ship_manage", Action::kShowShips},
+    {"research", Action::kShowResearch},
+    {"consumables", Action::kShowExoComp},
+    {"ship_recall", Action::kActionRecall},
+    {"show_keybindings", Action::kToggleShortcutHints},
+    {"gifts", Action::kShowGifts},
+    {"help_alliance", Action::kShowAllianceHelp},
+    {"officers", Action::kShowOfficers},
+    {"factions", Action::kShowFactions},
+    {"items", Action::kShowInventory},
+    {"refinery", Action::kShowRefinery},
+    {"commanders", Action::kShowCommander},
+    {"challenges", Action::kShowQTrials},
+});
+
+constexpr const NativeAction* FindNativeAction(std::string_view name)
+{
+  for (const auto& action : kNativeActions)
+    if (action.name == name)
+      return &action;
+  return nullptr;
+}
+
+consteval bool NativeActionsAreUnique()
+{
+  for (size_t i = 0; i < kNativeActions.size(); ++i)
+    for (size_t j = i + 1; j < kNativeActions.size(); ++j)
+      if (kNativeActions[i].name == kNativeActions[j].name)
+        return false;
+  return true;
+}
+
+static_assert(NativeActionsAreUnique());
+static_assert(FindNativeAction("side_chat")->fallback == Action::kShowChatSide2);
+static_assert(FindNativeAction("unknown") == nullptr);
+
+// The badge text for a native action: its mod binding, or "-" when it has none.
+std::string BadgeText(std::string_view action_name)
+{
+  const auto* action = FindNativeAction(action_name);
+  if (!action)
+    return "-";
+  auto hint_action = action->primary;
+  if (hint_action >= Action::kSelectShip1 && hint_action <= Action::kSelectShip8) {
+    // Use the same context array as FleetBarViewController::RequestSelect(int, bool), not the native dock index.
+    auto* bar     = unity::Newest<FleetBarViewController>();
+    auto* context = bar ? bar->CanvasContext() : nullptr;
+    auto* fleets  = context ? context->FleetData() : nullptr;
+    hint_action   = ShipShortcutHintAction(hint_action, fleets ? fleets->size() : 0, [fleets](std::size_t position) {
+      auto* fleet = (*fleets)[position];
+      return fleet ? fleet->Index() : -1;
+    });
+  }
+  auto hint = hint_action == Action::kCount ? std::string{} : Shortcut::Hint(hint_action);
+
+  if (hint.empty() && action->fallback != Action::kCount)
+
+    hint = Shortcut::Hint(action->fallback);
+  return hint.empty() ? "-" : hint;
+}
+
+using UpdateTextFn = void(ShortcutKeybindHint*);
+
+bool          installed            = false;
+UpdateTextFn* original_update_text = nullptr;
+
+void ShortcutKeybindHint_UpdateText_Hook(auto original, ShortcutKeybindHint* _this)
+{
+  auto* label = _this && installed ? _this->keyTextLocalizer() : nullptr;
+  if (!label)
+    return original(_this);
+
+  // UpdateText does not clear an existing override; clear ours first so native, disabled and unknown actions
+  // cannot keep a stale mod badge.
+  label->ClearTextOverride();
+  original(_this);
+
+  const auto& config = Config::Get();
+  if (!config.control.hotkeys_enabled || config.control.use_scopely_hotkeys)
+    return;
+
+  auto* reference = _this->inputAction();
+  auto* action    = reference ? reference->action() : nullptr;
+  auto* name      = action ? action->name() : nullptr;
+  if (name)
+    label->OverrideLocalizedText(il2cpp::NewString(BadgeText(il2cpp::ToUtf8(name)).c_str()));
+}
+
+void ShortcutKeybindHint_UpdateVisibility_Hook(auto original, ShortcutKeybindHint* _this, bool visible)
+{
+  original(_this, visible);
+  if (visible && installed && original_update_text)
+    ShortcutKeybindHint_UpdateText_Hook(original_update_text, _this);
+}
+} // namespace
+
+bool ToggleKeybindBadges()
+{
+  if (!installed)
+    return false;
+  auto* manager = ShortcutsManager::Instance();
+  if (!manager)
+    spdlog::warn("[Hotkeys] native shortcut hints are unavailable");
+  // The same gate the game's own show_keybindings action checks.
+  else if (ShortcutsManager::CanUseShortcuts())
+    manager->SetShowKeybindings(!manager->ShowKeybindings());
+  return true;
+}
+
+void HideKeybindBadges()
+{
+  auto* manager = installed ? ShortcutsManager::Instance() : nullptr;
+  if (manager && manager->ShowKeybindings())
+    manager->SetShowKeybindings(false);
+}
+
+void InstallKeybindBadges()
+{
+  // Settings are parsed before installation; NONE, empty and invalid bindings opt out.
+  if (!Shortcut::HasBinding(Action::kToggleShortcutHints))
+    return;
+
+  // Only the detour targets gate the feature. Members the badge path reads resolve on first use; a missing one is
+  // reported once and reads as null, which leaves the game's own badge text.
+  auto update_text       = ShortcutKeybindHint::Class::Method("UpdateText", 0);
+  auto update_visibility = ShortcutKeybindHint::Class::Method("UpdateVisibility", 1);
+  if (!update_text || !update_visibility)
+    return;
+
+  original_update_text = IL2CPP_HOOK(update_text, ShortcutKeybindHint_UpdateText_Hook);
+  installed = original_update_text && IL2CPP_HOOK(update_visibility, ShortcutKeybindHint_UpdateVisibility_Hook);
+}
diff --git a/mods/src/patches/parts/space_actions.cc b/mods/src/patches/parts/space_actions.cc
new file mode 100644
index 000000000..9659cb2b6
--- /dev/null
+++ b/mods/src/patches/parts/space_actions.cc
@@ -0,0 +1,556 @@
+// The selected fleet and the target viewers in space: selecting ships with the number keys, engaging, scanning,
+// mining, queueing, warping, recalling and repairing from the keyboard, dismissing viewers with Escape, opening a
+// target's cargo when it is scanned, and the action queue switch.
+
+#include "action_queue.h"
+#include "config.h"
+#include "patches/patches.h"
+#include "patches/shortcuts.h"
+#include <chrono>
+
+#include "prime/Hub.h"
+#include "prime/fleet.h"
+#include "prime/navigation.h"
+#include "prime/ui.h"
+#include "prime/viewers.h"
+
+#include <il2cpp/hook.h>
+#include <spdlog/spdlog.h>
+#include <unity/input.h>
+#include <unity/tracker.h>
+
+#include <algorithm>
+#include <chrono>
+#include <optional>
+#include <span>
+#include <utility>
+
+namespace
+{
+// Frames left in which to show the cargo of a pre-scanned target. The rewards widget can appear a few frames
+// after the pre-scan itself, so a request keeps trying for a while.
+int show_cargo_frames = 0;
+
+struct Pressed {
+  bool primary       = false;
+  bool secondary     = false;
+  bool queue         = false;
+  bool queue_clear   = false;
+  bool recall        = false;
+  bool recall_cancel = false;
+  bool repair        = false;
+  // A replay of last frame's press, see replay.
+  bool retry = false;
+
+  bool Any() const
+  { return primary || secondary || queue || queue_clear || recall || recall_cancel || repair; }
+};
+
+// The target's hull type is only known once the target's data has arrived; until then it reads as Any. A press
+// that lands in that window is replayed, as itself, on the next frame only.
+std::optional<Pressed> replay;
+
+bool Shown(VisibilityController* controller)
+{ return controller && controller->IsShown(); }
+
+template <typename T> bool TargetShown(T* widget, const Pressed& pressed)
+{
+  if (!widget || !Shown(widget->visibilityController()))
+    return false;
+  if (!pressed.primary || !Config::Get().control.primary_requires_visible_target)
+    return true;
+  auto* parent = widget->Parent();
+  return parent && parent->IsShowing();
+}
+
+// The cards that show a target or a place in space.
+template <typename... Viewers> struct ViewerList {
+  static bool AnyShown()
+  {
+    return (std::ranges::any_of(unity::Instances<Viewers>(),
+                                [](Viewers* widget) { return widget && Shown(widget->visibilityController()); })
+            || ...);
+  }
+
+  // Hides the shown viewers of the first type that has any.
+  static bool HideFirst()
+  { return (Hide<Viewers>() || ...); }
+
+private:
+  template <typename T> static bool Hide()
+  {
+    bool hid = false;
+    for (auto* widget : unity::Instances<T>()) {
+      if (widget && Shown(widget->visibilityController())) {
+        widget->HideAllViewers();
+        hid = true;
+      }
+    }
+    return hid;
+  }
+};
+
+using TargetViewers = ViewerList<AllianceStarbaseObjectViewerWidget, ArmadaObjectViewerWidget,
+                                 CelestialObjectViewerWidget, EmbassyObjectViewer, HousingObjectViewerWidget,
+                                 MiningObjectViewerWidget, MissionsObjectViewerWidget, PreScanTargetWidget>;
+
+HullType TargetHullType(BattleTargetData* context)
+{
+  auto* deployed = context ? context->TargetFleetDeployedData() : nullptr;
+  auto* hull     = deployed ? deployed->Hull() : nullptr;
+  return hull ? hull->Type() : HullType::Any;
+}
+
+// The armada viewer's state. A viewer without a visibility controller counts as visible.
+bool ArmadaViewerShown(ArmadaObjectViewerWidget* armada)
+{
+  if (!armada)
+    return false;
+  auto* controller = armada->visibilityController();
+  if (!controller) {
+    spdlog::warn("ArmadaWidget has no visibility controller, using default Visible state");
+    return true;
+  }
+  const auto state = controller->State();
+  return state == VisibilityState::Visible || state == VisibilityState::Show;
+}
+
+// The primary action joins a wave defense first: through the set-course widget's join button when it listens, else
+// the primary button of a shown wave defense viewer. Both press the game's own button, so its checks still run.
+bool JoinWaveDefense()
+{
+  if (auto* navigation = unity::Newest<NavigationInteractionUIViewController>();
+      navigation && navigation->TryPressJoinWaveDefense())
+    return true;
+  // Query active viewers without adding constructor detours for this popup or its subclasses.
+  if (auto* viewers = unity::FindObjectsOfType<WaveDefenseObjectViewerWidget>()) {
+    for (auto* widget : *viewers) {
+      auto* parent = widget && Shown(widget->visibilityController()) ? widget->Parent() : nullptr;
+      if (parent && parent->IsShowing()) {
+        // Use the displayed native action, including its eligibility and confirmation checks.
+        widget->PressPrimaryButton();
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// Requests `type` on the selected fleet when it is in one of `states`. With `help_state`, a fleet in that state
+// (or one the action was just requested for) also asks its alliance for help.
+bool RequestFleetAction(FleetBarViewController* fleet_bar, ActionType type, std::span<const FleetState> states,
+                        FleetState help_state = FleetState::Unknown)
+{
+  auto* panel = fleet_bar->fleetPanelController();
+  auto* fleet = panel ? panel->fleet() : nullptr;
+  if (!fleet)
+    return false;
+
+  bool requested = false;
+  if (std::ranges::find(states, fleet->CurrentState()) != states.end()) {
+    NavigationSectionManager::HideInteraction();
+    requested = panel->RequestAction(fleet, type, 0, ActionBehaviour::Default);
+  }
+  if (help_state != FleetState::Unknown && (requested || fleet->CurrentState() == help_state))
+    requested = requested || panel->RequestAction(fleet, type, 0, ActionBehaviour::AskHelp);
+  spdlog::trace("Fleet action {} on fleet {} in state {}: {}", type.flagValue, fleet->Id(),
+                static_cast<int>(fleet->CurrentState()), requested);
+  return requested;
+}
+
+// Acts on a shown pre-scan card. Returns true when the press was used, including when it was deferred to the next
+// frame.
+bool ActOnPreScan(PreScanTargetWidget* pre_scan, const Pressed& pressed, FleetPlayerData* fleet,
+                  ActionQueueManager* queue)
+{
+  auto* buttons = pre_scan->scanEngageButtonsWidget();
+
+  // A mining node's card sits on top of the pre-scan: scan it or start mining.
+  if (auto* mine = unity::Newest<MiningObjectViewerWidget>(); TargetShown(mine, pressed)) {
+    if (pressed.secondary && buttons) {
+      buttons->OnScanButtonClicked();
+      return true;
+    }
+    if (pressed.primary) {
+      mine->MineClicked();
+      return true;
+    }
+  }
+
+  auto* add_to_queue = pre_scan->addToQueueButtonWidget();
+  if (pressed.queue && queue->IsQueueUnlocked() && add_to_queue && buttons) {
+    const auto type = TargetHullType(buttons->Context());
+    if (type != HullType::ArmadaTarget && (type != HullType::Any || pressed.retry)) {
+      if (add_to_queue->isActiveAndEnabled()) {
+        if (auto* listener = add_to_queue->SemaphoreListener(); listener && !queue->IsQueueFull(fleet)) {
+          if (auto* button = listener->TheButton()) {
+            button->Press();
+            TargetViewers::HideFirst();
+          }
+        }
+        return true;
+      }
+      if (type == HullType::Any) {
+        replay = pressed;
+        return true;
+      }
+    }
+  }
+
+  if (pressed.secondary && buttons) {
+    buttons->OnScanButtonClicked();
+    return true;
+  }
+
+  if (pressed.primary && buttons && buttons->enabled()) {
+    const auto type = TargetHullType(buttons->Context());
+    // An armada target whose armada card is already open is joined from that card instead.
+    bool can_engage = type != HullType::Any;
+    if (type == HullType::ArmadaTarget && ArmadaViewerShown(unity::Newest<ArmadaObjectViewerWidget>()))
+      can_engage = false;
+    else if (pressed.retry)
+      can_engage = true;
+
+    if (can_engage) {
+      if (type != HullType::ArmadaTarget) {
+        buttons->OnEngageButtonClicked();
+      } else if (auto* attack = pre_scan->armadaAttackButton(); attack && attack->isActiveAndEnabled()) {
+        if (auto* button = attack->TheButton())
+          button->Press();
+      } else {
+        buttons->OnArmadaButtonClicked();
+      }
+      return true;
+    }
+    if (type == HullType::Any) {
+      replay = pressed;
+      return true;
+    }
+  }
+  return false;
+}
+
+// Acts on whatever other viewer is open: a mining node, a system node, or an empty spot in space. Returns true
+// when the press was used.
+bool ActOnViewer(const Pressed& pressed)
+{
+  if (auto* mine = unity::Newest<MiningObjectViewerWidget>(); TargetShown(mine, pressed)) {
+    if (auto* buttons = mine->scanEngageButtonsWidget(); pressed.secondary && buttons) {
+      if (!buttons->Context())
+        return false;
+      buttons->OnScanButtonClicked();
+      return true;
+    }
+    if (pressed.primary) {
+      mine->MineClicked();
+      return true;
+    }
+    return false;
+  }
+
+  if (auto* node = unity::Newest<StarNodeObjectViewerWidget>();
+      node && node->Context()
+      && (!pressed.primary || !Config::Get().control.primary_requires_visible_target || TargetShown(node, pressed))) {
+    if (pressed.secondary) {
+      node->OnViewButtonActivation();
+      return true;
+    }
+    if (pressed.primary) {
+      node->InitiateWarp();
+      return true;
+    }
+    return false;
+  }
+
+  auto* navigation = unity::Newest<NavigationInteractionUIViewController>();
+  if (!navigation || !pressed.primary)
+    return false;
+
+  auto* armada = unity::Newest<ArmadaObjectViewerWidget>();
+  if (!ArmadaViewerShown(armada)) {
+    if (Config::Get().control.primary_requires_visible_target && !navigation->IsSetCourseVisible())
+      return false;
+    navigation->OnSetCourseButtonClick();
+    return true;
+  }
+  if (auto* join = armada->joinContext(); join && join->Interactable()) {
+    armada->ValidateThenJoinArmada();
+    return true;
+  }
+  return false;
+}
+
+void ActOnSelectedFleet(FleetBarViewController* fleet_bar, const Pressed& pressed)
+{
+  if (Shortcut::IsDown(Action::kActionPrimary) && JoinWaveDefense())
+    return;
+  if (!fleet_bar)
+    return;
+  auto* panel = fleet_bar->fleetPanelController();
+  auto* fleet = panel ? panel->fleet() : nullptr;
+  auto* queue = ActionQueueManager::Instance();
+  if (!fleet || !queue)
+    return;
+
+  if (pressed.queue_clear) {
+    queue->ClearQueue(fleet);
+    return;
+  }
+  const auto state = fleet->CurrentState();
+  if (pressed.recall_cancel && (state == FleetState::WarpCharging || state == FleetState::Warping)) {
+    panel->CancelButtonClicked();
+    return;
+  }
+
+  for (auto* pre_scan : unity::Instances<PreScanTargetWidget>())
+    if (TargetShown(pre_scan, pressed) && ActOnPreScan(pre_scan, pressed, fleet, queue))
+      return;
+
+  if (ActOnViewer(pressed))
+    return;
+
+  static constexpr FleetState kRecallable[] = {FleetState::IdleInSpace, FleetState::Impulsing, FleetState::Mining,
+                                               FleetState::Capturing};
+  static constexpr FleetState kRepairable[] = {FleetState::Docked, FleetState::Destroyed};
+  if (pressed.recall && RequestFleetAction(fleet_bar, ActionType::Recall, kRecallable))
+    return;
+  if (pressed.repair)
+    RequestFleetAction(fleet_bar, ActionType::Repair, kRepairable, FleetState::Repairing);
+}
+
+// Toggles a shown pre-scan card's cargo panel. Opening is retried for a few frames, see show_cargo_frames.
+void ToggleTargetCargo()
+{
+  for (auto* pre_scan : unity::Instances<PreScanTargetWidget>()) {
+    auto* rewards = pre_scan ? pre_scan->rewardsButtonWidget() : nullptr;
+    auto* cargo   = rewards ? rewards->rewardsController() : nullptr;
+    if (!cargo || !Shown(pre_scan->visibilityController()))
+      continue;
+    if (cargo->IsShown())
+      cargo->Hide();
+    else
+      show_cargo_frames = 5;
+  }
+}
+
+void ShowPendingTargetCargo()
+{
+  for (auto* pre_scan : unity::Instances<PreScanTargetWidget>()) {
+    auto* rewards = pre_scan ? pre_scan->rewardsButtonWidget() : nullptr;
+    auto* cargo   = rewards ? rewards->rewardsController() : nullptr;
+    if (cargo && Shown(pre_scan->visibilityController()) && !cargo->IsShown())
+      cargo->Show(true);
+  }
+  --show_cargo_frames;
+}
+
+// Whether the target's cargo opens by itself, per the show_*_cargo settings for its kind.
+bool ShowsCargoByDefault(RewardsButtonWidget* widget)
+{
+  const auto& config = Config::Get();
+  auto*       target = widget && config.ui.show_cargo_default ? widget->Context() : nullptr;
+  if (!target)
+    return false;
+
+  auto* deployed = target->TargetFleetDeployedData();
+  if (!deployed)
+    return config.ui.show_station_cargo;
+  switch (deployed->FleetType()) {
+    case DeployedFleetType::Player:
+      return config.ui.show_player_cargo;
+    case DeployedFleetType::Marauder: {
+      auto* hull = deployed->Hull();
+      return hull && hull->Type() == HullType::ArmadaTarget ? config.ui.show_armada_cargo
+                                                            : config.ui.show_hostile_cargo;
+    }
+    default:
+      return false;
+  }
+}
+
+void ShowCargoByDefault(RewardsButtonWidget* widget)
+{
+  auto* cargo = widget ? widget->rewardsController() : nullptr;
+  if (cargo && ShowsCargoByDefault(widget)) {
+    cargo->Show(true);
+    show_cargo_frames = 1;
+  }
+}
+
+void RewardsButtonWidget_OnDidBindContext_Hook(auto original, RewardsButtonWidget* _this)
+{
+  original(_this);
+  ShowCargoByDefault(_this);
+}
+
+void PreScanTargetWidget_ShowWithFleet_Hook(auto original, PreScanTargetWidget* _this, void* fleet)
+{
+  original(_this, fleet);
+  if (_this)
+    ShowCargoByDefault(_this->rewardsButtonWidget());
+}
+
+// queue_enabled switches the game's action queue off by telling it the queue is locked.
+bool ActionQueueManager_IsQueueUnlocked_Hook(auto original, ActionQueueManager* _this)
+{ return Config::Get().control.queue_enabled && original(_this); }
+
+void ViewSelectedFleet(FleetPlayerData* fleet)
+{
+  NavigationSectionManager::HideInteraction();
+  if (auto* fleets = FleetsManager::Instance())
+    fleets->RequestViewFleet(fleet, true);
+}
+
+void InstallQueueSwitch()
+{ IL2CPP_HOOK(ActionQueueManager::Class::Method("IsQueueUnlocked"), ActionQueueManager_IsQueueUnlocked_Hook); }
+} // namespace
+
+bool TargetViewerShown()
+{ return TargetViewers::AnyShown(); }
+
+bool SelectShipShortcuts()
+{
+  using Clock = std::chrono::steady_clock;
+  // The number keys select a ship in the fleet bar; pressing the same one again within select_timer flies the
+  // camera to it. With disable_preview_locate, the second press only selects while a target card is open.
+  constexpr Action kShips[] = {Action::kSelectShip1, Action::kSelectShip2, Action::kSelectShip3, Action::kSelectShip4,
+                               Action::kSelectShip5, Action::kSelectShip6, Action::kSelectShip7, Action::kSelectShip8};
+  static auto      last_press = Clock::now();
+  static int32_t   last_index = -1;
+
+  int32_t index = 0;
+  while (index < 8 && !Shortcut::IsDown(kShips[index]))
+    ++index;
+  // TODO: Shift+ship used to request a tow by the Discovery. Its bindings had drifted, so it never ran on
+  // recent clients, and it was disabled until someone verifies it in game. Shift+ship does nothing meanwhile.
+  if (index == 8 || unity::Key::IsInputFocused())
+    return false;
+
+  auto* fleet_bar = unity::Newest<FleetBarViewController>();
+  if (!fleet_bar)
+    return false;
+
+  const auto now        = Clock::now();
+  const bool can_locate = !Config::Get().ui.disable_preview_locate || !TargetViewerShown();
+  if (can_locate && index == last_index && fleet_bar->IsIndexSelected(index)
+      && now - last_press < std::chrono::milliseconds(Config::Get().control.select_timer)) {
+    auto* fleet = fleet_bar->SelectedFleet();
+    if (!fleet)
+      return true;
+    ViewSelectedFleet(fleet);
+  } else {
+    fleet_bar->RequestSelect(index);
+  }
+  last_index = index;
+  last_press = now;
+  return true;
+}
+
+bool FleetShortcuts()
+{
+  if (Shortcut::IsDown(Action::kSelectCurrent)) {
+    auto* fleet_bar = unity::Newest<FleetBarViewController>();
+    if (auto* fleet = fleet_bar ? fleet_bar->SelectedFleet() : nullptr) {
+      ViewSelectedFleet(fleet);
+      return true;
+    }
+  }
+  if (Shortcut::IsDown(Action::kToggleQueue)) {
+    auto& queue_enabled = Config::Get().control.queue_enabled;
+    queue_enabled       = !queue_enabled;
+    ResetQueueRecoveryTracking();
+    return true;
+  }
+  return false;
+}
+
+bool FleetActionShortcuts()
+{
+  // A replay lives for exactly the next frame, whatever that frame does.
+  const auto replayed = std::exchange(replay, std::nullopt);
+  if (unity::Key::IsInputFocused())
+    return false;
+
+  if (unity::Key::Pressed(unity::KeyCode::Escape) && TargetViewers::HideFirst())
+    return true;
+
+  // Escape or the primary action dismisses the golden rewards screen. Down, not Pressed: a held Escape would go
+  // back a section every frame while the screen closes.
+  if (Shortcut::IsDown(Action::kActionPrimary) || unity::Key::Down(unity::KeyCode::Escape)) {
+    if (auto* rewards = unity::Newest<AnimatedRewardsScreenViewController>(); rewards && rewards->IsActive()) {
+      rewards->GoBackToLastSection();
+      return true;
+    }
+  }
+
+  Pressed pressed{
+      .primary     = Shortcut::IsDown(Action::kActionPrimary),
+      .secondary   = Shortcut::IsDown(Action::kActionSecondary),
+      .queue       = Shortcut::IsDown(Action::kActionQueue),
+      .queue_clear = Shortcut::IsDown(Action::kActionQueueClear),
+      // With disable_preview_recall, recall only works while no target card is open.
+      .recall =
+          Shortcut::IsDown(Action::kActionRecall) && (!Config::Get().ui.disable_preview_recall || !TargetViewerShown()),
+      .recall_cancel = Shortcut::IsDown(Action::kActionRecallCancel),
+      .repair        = Shortcut::IsDown(Action::kActionRepair),
+  };
+  if (replayed && !pressed.Any()) {
+    pressed       = *replayed;
+    pressed.retry = true;
+  }
+  if (pressed.Any() && Hub::IsInSystemOrGalaxyOrStarbase() && !Hub::IsInChat())
+    ActOnSelectedFleet(unity::Newest<FleetBarViewController>(), pressed);
+
+  if (Shortcut::IsDown(Action::kActionView))
+    ToggleTargetCargo();
+  if (show_cargo_frames > 0)
+    ShowPendingTargetCargo();
+  return false;
+}
+
+void InstallFleetActions()
+{
+  IL2CPP_HOOK(RewardsButtonWidget::Class::Method("OnDidBindContext"), RewardsButtonWidget_OnDidBindContext_Hook);
+  IL2CPP_HOOK(PreScanTargetWidget::Class::Method("ShowWithFleet"), PreScanTargetWidget_ShowWithFleet_Hook);
+}
+
+const Feature kQueueSwitch{"QueueSwitch", &Config::Patches::testpatches, InstallQueueSwitch};
+
+namespace
+{
+void UpdateExpiredAbilityButtons()
+{
+  static auto next_update = std::chrono::steady_clock::time_point{};
+  const auto  now         = std::chrono::steady_clock::now();
+  if (now < next_update)
+    return;
+  next_update      = now + std::chrono::milliseconds(250);
+  auto* bar        = unity::Newest<FleetBarViewController>();
+  auto* controller = bar ? bar->fleetPanelController() : nullptr;
+  auto* fleet      = controller ? controller->fleet() : nullptr;
+  if (!fleet || (static_cast<int>(fleet->CurrentState()) & static_cast<int>(FleetState::CanActivateAbility)) == 0)
+    return;
+  auto* manager = ActivatedAbilityManager::Instance();
+  auto* panel   = controller->shipActionPanelLocalViewController();
+  auto* canvas  = panel ? CanvasController::Of(panel) : nullptr;
+  if (!manager || !canvas || !canvas->Visible() || panel->HasShipAnActiveAbilityWithActiveEffect())
+    return;
+  auto* ids     = panel->abilityIDs();
+  auto* buttons = panel->buttons();
+  if (!ids || !buttons)
+    return;
+  for (size_t index = 0; index < ids->size() && index < buttons->size(); ++index) {
+    auto* button  = (*buttons)[index];
+    auto* context = button ? button->Context() : nullptr;
+    if (!button || !button->isActiveAndEnabled() || !context || context->Interactable())
+      continue;
+    const auto ability_id = (*ids)[index];
+    auto*      timer      = panel->GetRemainingCooldown(ability_id);
+    // TimeSpan is an eight-byte value in 100 ns ticks. Repair at -1 second or below.
+    if (timer && timer->RemainingTime().ticks <= -10000000 && manager->CanUseAbility(fleet, ability_id))
+      context->SetInteractable(true);
+  }
+}
+
+} // namespace
+const Feature kAbilityButtons{"AbilityButtons", &Config::Patches::hotkeyhooks, nullptr, UpdateExpiredAbilityButtons};
diff --git a/mods/src/patches/parts/sync.cc b/mods/src/patches/parts/sync.cc
deleted file mode 100644
index 562036e7b..000000000
--- a/mods/src/patches/parts/sync.cc
+++ /dev/null
@@ -1,3538 +0,0 @@
-#include "config.h"
-#include "errormsg.h"
-#include "file.h"
-#include "patches/fleet_watch.h"
-#include "patches/screen_update_hook.h"
-#include "str_utils.h"
-
-#include <Digit.PrimePlatform.Content.pb.h>
-#include <Digit.PrimeServer.Models.pb.h>
-#include <stfc.sync.pb.h>
-#include <il2cpp/il2cpp.h>
-#include <prime/EntityGroup.h>
-#include <prime/FleetsManager.h>
-#include <prime/Hub.h>
-#include <prime/RealtimeDataPayload.h>
-#include <prime/ServiceResponse.h>
-#include <prime/UserProfileManager.h>
-#include <spud/detour.h>
-
-#include <spdlog/spdlog.h>
-#if !__cpp_lib_format
-#include <spdlog/fmt/fmt.h>
-#endif
-
-#if _WIN32
-#include <rpc.h>
-#include <winrt/Windows.Foundation.h>
-#include <winrt/Windows.Web.Http.Headers.h>
-#else
-#include <uuid/uuid.h>
-#endif
-
-#include <EASTL/algorithm.h>
-#include <EASTL/bonus/ring_buffer.h>
-#include <cpr/cpr.h>
-#include <curl/curl.h>
-#include <nlohmann/json.hpp>
-
-#include <algorithm>
-#include <atomic>
-#include <charconv>
-#include <chrono>
-#include <cmath>
-#include <condition_variable>
-#include <filesystem>
-#include <format>
-#include <fstream>
-#include <mutex>
-#include <optional>
-#include <queue>
-#include <ranges>
-#include <string>
-#include <string_view>
-#include <thread>
-#include <tuple>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-#ifndef STR_FORMAT
-#if __cpp_lib_format
-#define STR_FORMAT std::format
-#else
-#define STR_FORMAT fmt::format
-#endif
-#endif
-
-#ifndef _WIN32
-#include <time.h>
-#endif
-
-#if _WIN32
-// Introduce RAII guard for COM apartments
-struct WinRtApartmentGuard {
-  WinRtApartmentGuard() { winrt::init_apartment(); }
-  ~WinRtApartmentGuard() { winrt::uninit_apartment(); }
-};
-#endif
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-template <typename T> struct adl_serializer<google::protobuf::RepeatedField<T>> {
-  static void to_json(json& j, const google::protobuf::RepeatedField<T>& proto)
-  {
-    j = json::array();
-
-    for (const auto& v : proto) {
-      j.push_back(v);
-    }
-  }
-
-  static void from_json(const json& j, google::protobuf::RepeatedField<T>& proto)
-  {
-    if (j.is_array()) {
-      for (const auto& v : j) {
-        proto.Add(v.get<T>());
-      }
-    }
-  }
-};
-
-template <> struct adl_serializer<SyncConfig::Type> {
-  static void to_json(json& j, const SyncConfig::Type t)
-  {
-    for (const auto& opt : SyncOptions) {
-      if (opt.type == t) {
-        j = opt.type_str;
-        return;
-      }
-    }
-
-    j = nullptr;
-  }
-
-  static void from_json(const json& j, SyncConfig::Type& t)
-  {
-    if (j.is_string()) {
-      const auto& s = j.get_ref<const std::string&>();
-
-      for (const auto& opt : SyncOptions) {
-        if (opt.type_str == s) {
-          t = opt.type;
-          return;
-        }
-      }
-    }
-  }
-};
-NLOHMANN_JSON_NAMESPACE_END
-
-namespace http
-{
-
-namespace headers
-{
-  static std::string    gameServerUrl;
-  static std::string    instanceSessionId;
-  static int32_t        instanceId;
-  static std::string    unityVersion{"6000.0.59f2-deadlock-fix-test"};
-  static std::string    primeVersion{"1.000.51336"};
-  static std::string    poweredBy{"stfc community mod/" VER_FILE_VERSION_STR};
-} // namespace headers
-
-namespace logging
-{
-  static constexpr std::string CURL_TYPE_UPLOAD   = "UPLOAD";
-  static constexpr std::string CURL_TYPE_DOWNLOAD = "DOWNLOAD";
-
-  static void error(const std::string& type, const std::string& target, const std::string& text)
-  {
-    if (Config::Get().sync_logging) {
-      spdlog::error("SYNC-{} - {}: {}", type, target, text);
-    }
-  }
-
-  static void warn(const std::string& type, const std::string& target, const std::string& text)
-  {
-    if (Config::Get().sync_logging) {
-      spdlog::warn("SYNC-{} - {}: {}", type, target, text);
-    }
-  }
-
-  static void info(const std::string& type, const std::string& target, const std::string& text)
-  {
-    if (Config::Get().sync_logging) {
-      spdlog::info("SYNC-{} - {}: {}", type, target, text);
-    }
-  }
-
-  static void debug(const std::string& type, const std::string& target, const std::string& text)
-  {
-    if (Config::Get().sync_logging && Config::Get().sync_debug) {
-      spdlog::debug("SYNC-{} - {}: {}", type, target, text);
-    }
-  }
-
-  static void trace(const std::string& type, const std::string& target, const std::string& text)
-  {
-    if (Config::Get().sync_logging && Config::Get().sync_debug) {
-      spdlog::trace("SYNC-{} - {}: {}", type, target, text);
-    }
-  }
-}
-
-[[nodiscard]] static std::string newUUID()
-{
-#ifdef _WIN32
-  UUID uuid;
-  UuidCreate(&uuid);
-
-  unsigned char* str;
-  UuidToStringA(&uuid, &str);
-
-  std::string s(reinterpret_cast<char*>(str));
-
-  RpcStringFreeA(&str);
-#else
-  uuid_t uuid;
-  uuid_generate_random(uuid);
-  char s[37];
-  uuid_unparse(uuid, s);
-#endif
-  return s;
-}
-
-// Simple URL manipulation class to replace boost::url
-class Url
-{
-public:
-  explicit Url(std::string url) : m_url(std::move(url))
-  {
-    m_handle = curl_url();
-    if (m_handle != nullptr) {
-      curl_url_set(m_handle, CURLUPART_URL, m_url.data(), 0);
-    }
-  }
-
-  ~Url()
-  {
-    if (m_handle != nullptr) {
-      curl_url_cleanup(m_handle);
-    }
-  }
-
-  // Delete copy operations to prevent double-free
-  Url(const Url&) = delete;
-  Url& operator=(const Url&) = delete;
-
-  Url(Url&& other) noexcept : m_handle(other.m_handle), m_url(std::move(other.m_url))
-  {
-    other.m_handle = nullptr;
-  }
-
-  Url& operator=(Url&& other) noexcept
-  {
-    if (this != &other) {
-      if (m_handle != nullptr) {
-        curl_url_cleanup(m_handle);
-      }
-
-      m_handle = other.m_handle;
-      m_url = std::move(other.m_url);
-      other.m_handle = nullptr;
-    }
-
-    return *this;
-  }
-
-  void set_path(const std::string& path)
-  {
-    if (m_handle == nullptr) {
-      return;
-    }
-
-    if (CURLUcode rc = curl_url_set(m_handle, CURLUPART_PATH, path.c_str(), 0); rc == CURLUE_OK) {
-      char *url = nullptr;
-      if (rc = curl_url_get(m_handle, CURLUPART_URL , &url, CURLU_PUNYCODE); rc == CURLUE_OK) {
-        m_url = url;
-      }
-
-      if (url != nullptr) {
-        curl_free(url);
-      }
-    }
-  }
-
-  [[nodiscard]] const char* c_str() const
-  {
-    return m_url.c_str();
-  }
-
-private:
-  CURLU *m_handle;
-  std::string m_url;
-};
-
-// Per-target worker thread infrastructure
-struct TargetWorker {
-  TargetWorker() = default;
-  TargetWorker(const TargetWorker&) = delete;
-  TargetWorker& operator=(const TargetWorker&) = delete;
-
-  using request_t = std::tuple<std::string, std::string, bool>;
-
-  std::shared_ptr<cpr::Session> session;
-  std::thread                   worker_thread;
-  std::atomic_bool              stop_requested{false};
-  std::queue<request_t>         request_queue;
-  std::mutex                    queue_mtx;
-  std::condition_variable       queue_cv;
-};
-
-static std::unordered_map<std::string, std::shared_ptr<TargetWorker>> target_workers;
-static std::mutex target_workers_mtx;
-
-static void target_worker_thread(std::shared_ptr<TargetWorker> worker)
-{
-#if _WIN32
-  WinRtApartmentGuard apartmentGuard;
-#endif
-
-  while (!worker->stop_requested.load(std::memory_order_acquire)) {
-    std::string identifier;
-    std::string post_data;
-    bool is_first_sync = false;
-
-    {
-      std::unique_lock lk(worker->queue_mtx);
-      worker->queue_cv.wait(lk, [&worker] {
-        return worker->stop_requested.load(std::memory_order_acquire) || !worker->request_queue.empty();
-      });
-
-      if (worker->stop_requested.load(std::memory_order_acquire) && worker->request_queue.empty()) {
-        break;
-      }
-
-      if (!worker->request_queue.empty()) {
-        auto item = std::move(worker->request_queue.front());
-        worker->request_queue.pop();
-        identifier = std::move(std::get<0>(item));
-        post_data = std::move(std::get<1>(item));
-        is_first_sync = std::get<2>(item);
-      }
-    }
-
-    if (post_data.empty()) {
-      continue;
-    }
-
-    // Process the request
-    try {
-      const auto httpClient = worker->session;
-      auto& headers = httpClient->GetHeader();
-
-      if (is_first_sync) {
-        headers.insert_or_assign("X-PRIME-SYNC", "2");
-        logging::trace(logging::CURL_TYPE_UPLOAD, identifier, "Adding X-Prime-Sync header for initial sync");
-      } else {
-        headers.erase("X-PRIME-SYNC");
-      }
-
-      httpClient->SetBody(cpr::Body{post_data});
-
-      logging::debug(logging::CURL_TYPE_UPLOAD, identifier, "Sending data to " + httpClient->GetFullRequestUrl());
-
-      // Synchronously wait for response
-      const auto response = httpClient->Post();
-
-      if (response.status_code == 0) {
-        logging::error(logging::CURL_TYPE_UPLOAD, identifier, "Failed to send request: " + response.error.message);
-      } else if (response.status_code >= 400) {
-        if (response.status_code == 501) {
-          logging::error(logging::CURL_TYPE_UPLOAD, identifier, STR_FORMAT("Sync target does not support this operation ({}, after {:.0f} ms). Consider turning off this upload category for the target.", response.status_line, response.elapsed * 1'000));
-        } else {
-          logging::error(logging::CURL_TYPE_UPLOAD, identifier, STR_FORMAT("Failed to communicate with server: {} (after {:.0f} ms)", response.status_line, response.elapsed * 1'000));
-        }
-      } else {
-        logging::debug(logging::CURL_TYPE_UPLOAD, identifier, STR_FORMAT("Response: {} ({:.0f} ms elapsed)", response.status_line, response.elapsed * 1'000));
-      }
-    } catch (const std::runtime_error& e) {
-      ErrorMsg::SyncRuntime(identifier.c_str(), e);
-    } catch (const std::exception& e) {
-      ErrorMsg::SyncException(identifier.c_str(), e);
-#if _WIN32
-    } catch (winrt::hresult_error const& ex) {
-      ErrorMsg::SyncWinRT(identifier.c_str(), ex);
-#endif
-    } catch (...) {
-      ErrorMsg::SyncMsg(identifier.c_str(), "Unknown error occurred");
-    }
-  }
-}
-
-static std::shared_ptr<TargetWorker> get_curl_client_sync(const std::string& target)
-{
-  std::scoped_lock lk(target_workers_mtx);
-
-  // Check if a worker already exists
-  if (const auto it = target_workers.find(target); it != target_workers.end()) {
-    return it->second;
-  }
-
-  // Create a new worker for this target
-  auto worker = std::make_shared<TargetWorker>();
-
-  // Initialize session
-  worker->session = std::make_shared<cpr::Session>();
-  const auto& target_config = Config::Get().sync_targets[target];
-
-  worker->session->SetUrl(target_config.url);
-  worker->session->SetUserAgent("stfc community mod " VER_FILE_VERSION_STR " (libcurl/" LIBCURL_VERSION ")");
-  worker->session->SetAcceptEncoding(cpr::AcceptEncoding{});
-  worker->session->SetHttpVersion(cpr::HttpVersion{cpr::HttpVersionCode::VERSION_1_1});
-  worker->session->SetRedirect(cpr::Redirect{3, true, false, cpr::PostRedirectFlags::POST_ALL});
-
-#ifndef _MODDBG
-  worker->session->SetConnectTimeout(cpr::ConnectTimeout{3'000});
-  worker->session->SetTimeout(cpr::Timeout{10'000});
-#endif
-
-  spdlog::debug("sync target '{}': proxy='{}', verify_ssl={}", target, target_config.proxy, target_config.verify_ssl);
-
-  if (!target_config.proxy.empty()) {
-    worker->session->SetProxies({{"http", target_config.proxy}, {"https", target_config.proxy}});
-  }
-
-  if (!target_config.verify_ssl) {
-    worker->session->SetSslOptions(
-      cpr::Ssl(cpr::ssl::VerifyHost{false}, cpr::ssl::VerifyPeer{false}, cpr::ssl::NoRevoke{true})
-    );
-  }
-
-  worker->session->SetHeader({
-    {"Content-Type", "application/json"},
-    {"X-Powered-By", headers::poweredBy},
-    {"stfc-sync-token", target_config.token},
-  });
-
-  // Start the worker thread
-  worker->worker_thread = std::thread(target_worker_thread, worker);
-  target_workers[target] = worker;
-
-  return worker;
-}
-
-static void send_data(SyncConfig::Type type, const std::string& post_data, bool is_first_sync)
-{
-  static std::once_flag emit_warning;
-  const auto& targets = Config::Get().sync_targets;
-
-  std::call_once(emit_warning, [targets] {
-    if (targets.empty()) {
-      logging::warn(logging::CURL_TYPE_UPLOAD, "GLOBAL", "No target found, will not attempt to send");
-    }
-  });
-
-  for (const auto& target : targets
-       | std::views::filter([type](const auto& t) { return t.second.enabled(type); })
-       | std::views::keys) {
-
-    const auto target_identifier = STR_FORMAT("{} ({})", target, to_string(type));
-
-    try {
-      const auto worker = get_curl_client_sync(target);
-
-      // Enqueue the request for this target's worker
-      {
-        std::scoped_lock lk(worker->queue_mtx);
-        worker->request_queue.emplace(target_identifier, post_data, is_first_sync);
-        logging::trace(logging::CURL_TYPE_UPLOAD, target_identifier,
-                       STR_FORMAT("Queued request (queue size: {})", worker->request_queue.size()));
-      }
-      worker->queue_cv.notify_all();
-
-    } catch (const std::runtime_error& e) {
-      spdlog::error("Failed to send sync data to target '{}' - Runtime error: {}", target_identifier, e.what());
-    } catch (const std::exception& e) {
-      spdlog::error("Failed to send sync data to target '{}' - Exception: {}", target_identifier, e.what());
-    } catch (...) {
-      spdlog::error("Failed to send sync data to target '{}' - Unknown error occurred", target_identifier);
-    }
-  }
-}
-
-static std::shared_ptr<cpr::Session> get_curl_client_scopely()
-{
-  static std::shared_ptr<cpr::Session> session{nullptr};
-  static std::once_flag init_flag;
-
-  // thread-safe initialization
-  std::call_once(init_flag, [] {
-    session = std::make_shared<cpr::Session>();
-    session->SetAcceptEncoding(cpr::AcceptEncoding{});
-    session->SetHttpVersion(cpr::HttpVersion{cpr::HttpVersionCode::VERSION_1_1});
-
-    spdlog::debug("scopely session: proxy='{}', verify_ssl={}", Config::Get().sync_options.proxy, Config::Get().sync_options.verify_ssl);
-
-    if (!Config::Get().sync_options.proxy.empty()) {
-      session->SetProxies({{"https", Config::Get().sync_options.proxy}});
-    }
-
-    if (!Config::Get().sync_options.verify_ssl) {
-      session->SetSslOptions(
-        cpr::Ssl(cpr::ssl::VerifyHost{false}, cpr::ssl::VerifyPeer{false}, cpr::ssl::NoRevoke{true})
-      );
-    }
-
-    session->SetUserAgent("UnityPlayer/" + headers::unityVersion + " (UnityWebRequest/1.0, libcurl/8.10.1-DEV)");
-    session->SetHeader({
-        {"Accept", "application/json"},
-        {"Content-Type", "application/json"},
-        {"X-TRANSACTION-ID", newUUID()},
-        {"X-AUTH-SESSION-ID", headers::instanceSessionId},
-        {"X-PRIME-VERSION", headers::primeVersion},
-        {"X-Instance-ID", STR_FORMAT("{:03}", headers::instanceId)},
-        {"X-PRIME-SYNC", "0"},
-        {"X-Unity-Version", headers::unityVersion},
-        {"X-Powered-By", headers::poweredBy},
-    });
-  });
-
-  return session;
-}
-
-static std::string get_scopely_data(const std::string& path, const std::string& post_data)
-{
-  static std::once_flag emit_warning;
-
-  if (Config::Get().sync_targets.empty()) {
-    std::call_once(emit_warning, [] {
-      logging::warn(logging::CURL_TYPE_UPLOAD, "GLOBAL", "No target found, will not attempt to retrieve data");
-    });
-
-    return {};
-  }
-
-  Url url(headers::gameServerUrl);
-  url.set_path(path);
-
-  const auto        httpClient = get_curl_client_scopely();
-  static std::mutex client_mutex;
-
-  std::string response_text;
-
-  {
-    std::scoped_lock lk(client_mutex);
-    httpClient->SetUrl(url.c_str());
-
-    auto& headers = httpClient->GetHeader();
-    headers.insert_or_assign("X-TRANSACTION-ID", newUUID());
-    headers.insert_or_assign("X-AUTH-SESSION-ID", headers::instanceSessionId);
-    headers.insert_or_assign("X-Instance-ID", STR_FORMAT("{:03}", headers::instanceId));
-
-    httpClient->SetBody(post_data);
-    const auto response = httpClient->Post();
-
-    if (response.status_code == 0) {
-      logging::error(logging::CURL_TYPE_DOWNLOAD, path, "Failed to send request: " + response.error.message);
-      return {};
-    }
-
-    if (response.status_code >= 400) {
-      logging::error(logging::CURL_TYPE_DOWNLOAD, path, "Failed to communicate with server: " + response.status_line);
-      return {};
-    }
-
-    const auto  response_headers = response.header;
-    std::string type;
-
-    try {
-      type = response_headers.at("Content-Type");
-    } catch (const std::out_of_range&) {
-      type = "unknown";
-    }
-
-    logging::debug(logging::CURL_TYPE_DOWNLOAD, path,
-                   STR_FORMAT("Response: {} ({}), {:.0f} ms elapsed,", response.status_line, type, response.elapsed * 1'000));
-    response_text = response.text;
-  }
-
-  return response_text;
-}
-
-} // namespace http
-
-namespace trackers
-{
-
-namespace types
-{
-  struct RankLevelState {
-    explicit RankLevelState(const int32_t r = -1, const int32_t l = -1)
-        : rank(r)
-        , level(l)
-    {
-    }
-
-    bool operator==(const RankLevelState& other) const
-    { return this->rank == other.rank && this->level == other.level; }
-
-  private:
-    int64_t rank  = -1;
-    int64_t level = -1;
-  };
-
-  struct RankLevelShardsState {
-    explicit RankLevelShardsState(const int32_t r = -1, const int32_t l = -1, const int32_t s = -1)
-        : rank(r)
-        , level(l)
-        , shards(s)
-    {
-    }
-
-    bool operator==(const RankLevelShardsState& other) const
-    { return this->rank == other.rank && this->level == other.level && this->shards == other.shards; }
-
-  private:
-    int32_t rank   = -1;
-    int32_t level  = -1;
-    int32_t shards = -1;
-  };
-
-  struct ShipState {
-    explicit ShipState(const int32_t t = -1, const int32_t l = -1, const double_t lp = -1.0,
-                       const std::vector<int64_t>& c = {})
-        : tier(t)
-        , level(l)
-        , level_percentage(lp)
-        , components(c)
-    {
-    }
-
-    bool operator==(const ShipState& other) const
-    {
-      return this->tier == other.tier && this->level == other.level
-             && std::fabs(this->level_percentage - other.level_percentage) < 0.01
-             && this->components == other.components;
-    }
-
-  private:
-    int32_t              tier             = -1;
-    int32_t              level            = -1;
-    double_t             level_percentage = -1.0;
-    std::vector<int64_t> components;
-  };
-
-  struct PlanetaryBaseState {
-    explicit PlanetaryBaseState(const int32_t l = -1, const int32_t s = -1, const int64_t p = -1)
-        : level(l)
-        , status(s)
-        , position(p)
-    {
-    }
-
-    bool operator==(const PlanetaryBaseState& other) const
-    { return this->level == other.level && this->status == other.status && this->position == other.position; }
-
-  private:
-    int32_t level    = -1;
-    int32_t status   = -1;
-    int64_t position = -1;
-  };
-
-  struct pairhash {
-    template <typename T, typename U> std::size_t operator()(const std::pair<T, U>& x) const
-    { return std::hash<T>()(x.first) ^ std::hash<U>()(x.second); }
-  };
-
-  struct CachedPlayerData {
-    std::string                           name;
-    int64_t                               alliance{-1};
-    std::chrono::steady_clock::time_point expires_at;
-  };
-
-  struct CachedAllianceData {
-    std::string                           name;
-    std::string                           tag;
-    std::chrono::steady_clock::time_point expires_at;
-  };
-} // namespace types
-
-namespace names
-{
-  using namespace types;
-
-  static std::unordered_map<std::string, CachedPlayerData> player_data_cache;
-  static std::mutex                                        player_data_cache_mtx;
-
-  static std::unordered_map<int64_t, CachedAllianceData> alliance_data_cache;
-  static std::mutex                                      alliance_data_cache_mtx;
-
-  static void cache_player_names(std::unique_ptr<std::string>&& bytes)
-  {
-    if (auto response = Digit::PrimeServer::Models::UserProfilesResponse(); response.ParseFromString(*bytes)) {
-
-      std::unordered_map<std::string, CachedPlayerData> names;
-      const auto                                        expires_at =
-          std::chrono::steady_clock::now() + std::chrono::seconds(Config::Get().sync_resolver_cache_ttl);
-
-      for (const auto& profile : response.userprofiles()) {
-        names.insert_or_assign(
-            profile.userid(),
-            CachedPlayerData{.name = profile.name(), .alliance = profile.allianceid(), .expires_at = expires_at});
-      }
-
-      {
-        std::scoped_lock lk(player_data_cache_mtx);
-        player_data_cache.insert(names.begin(), names.end());
-      }
-    } else {
-      spdlog::error("Failed to parse user profile");
-    }
-  }
-
-  static void cache_alliance_names(std::unique_ptr<std::string>&& bytes)
-  {
-    if (auto response = Digit::PrimeServer::Models::GetAllianceProfilesResponse(); response.ParseFromString(*bytes)) {
-
-      std::unordered_map<int64_t, CachedAllianceData> names;
-      const auto                                      expires_at =
-          std::chrono::steady_clock::now() + std::chrono::seconds(Config::Get().sync_resolver_cache_ttl);
-
-      for (const auto& alliance : response.allianceprofiles()) {
-        if (alliance.id() > 0) {
-          names.insert_or_assign(
-              alliance.id(),
-              CachedAllianceData{.name = alliance.name(), .tag = alliance.tag(), .expires_at = expires_at});
-        }
-      }
-
-      {
-        std::scoped_lock lk(alliance_data_cache_mtx);
-        alliance_data_cache.insert(names.begin(), names.end());
-      }
-
-    } else {
-      spdlog::error("Failed to parse alliance profile");
-    }
-  }
-
-  static inline void collect_user_ids_from_fleet(const nlohmann::json&            fleet_data,
-                                                 std::unordered_set<std::string>& user_ids)
-  {
-    if (!fleet_data.contains("ref_ids") || fleet_data["ref_ids"].is_null()) {
-      for (const auto& fleet : fleet_data["deployed_fleets"]) {
-        const auto& player_id = fleet["uid"].get<std::string>();
-        user_ids.insert(player_id);
-      }
-    }
-  }
-
-  // Cracked stations have no fleet, so a base raid's defender isn't in deployed_fleets -- take the
-  // participant ids from the journal instead.
-  static inline void collect_journal_participants(const nlohmann::json&            journal,
-                                                  std::unordered_set<std::string>& user_ids)
-  {
-    for (const char* key : {"initiator_id", "target_id"}) {
-      if (!journal.contains(key) || journal[key].is_null()) {
-        continue;
-      }
-      const auto& id = journal[key].get<std::string>();
-      // NPC ids contain '_' (mar_61, npc_<id>_1); player ids don't -- skip, nothing to resolve.
-      if (!id.empty() && id.find('_') == std::string::npos) {
-        user_ids.insert(id);
-      }
-    }
-  }
-
-  static inline void collect_alliance_ids(const nlohmann::json& names, std::unordered_set<int64_t>& alliance_ids)
-  {
-    for (const auto& [player_id, entry] : names.items()) {
-      try {
-        const auto alliance_id = entry["alliance_id"].get<int64_t>();
-        alliance_ids.insert(alliance_id);
-      } catch (const nlohmann::json::exception&) {
-      }
-    }
-  }
-
-  static void resolve_player_names(const std::unordered_set<std::string>& user_ids, nlohmann::json& out_names,
-                                   nlohmann::json&                                          out_request_ids,
-                                   const std::chrono::time_point<std::chrono::steady_clock> now)
-  {
-    std::scoped_lock lk(player_data_cache_mtx);
-
-    for (const auto& user_id : user_ids) {
-      const auto it = player_data_cache.find(user_id);
-      if (it != player_data_cache.end()) {
-        if (it->second.expires_at > now) {
-          out_names[user_id] = {{"name", it->second.name},
-                                {"alliance_id", it->second.alliance},
-                                {"alliance_name", nullptr},
-                                {"alliance_tag", nullptr}};
-        } else {
-          // expired entry: erase and queue for fetch
-          player_data_cache.erase(it);
-          out_request_ids.push_back(user_id);
-        }
-      } else {
-        // cache miss: queue for fetch
-        out_request_ids.push_back(user_id);
-      }
-    }
-  }
-
-  static void resolve_alliance_names(const std::unordered_set<int64_t>& alliance_ids, nlohmann::json& out_names,
-                                     nlohmann::json&                                          out_request_ids,
-                                     const std::chrono::time_point<std::chrono::steady_clock> now)
-  {
-    std::scoped_lock lk(alliance_data_cache_mtx);
-
-    for (const auto& alliance_id : alliance_ids) {
-      const auto it = alliance_data_cache.find(alliance_id);
-      if (it != alliance_data_cache.end()) {
-        if (it->second.expires_at > now) {
-          for (const auto& [player_id, entry] : out_names.items()) {
-            try {
-              if (entry["alliance_id"].get<int64_t>() == alliance_id) {
-                entry["alliance_name"] = it->second.name;
-                entry["alliance_tag"]  = it->second.tag;
-                entry.erase("alliance_id");
-              }
-            } catch (const nlohmann::json::exception&) {
-            }
-          }
-        } else {
-          // expired entry: erase and queue for fetch
-          alliance_data_cache.erase(it);
-          out_request_ids.push_back(alliance_id);
-        }
-      }
-    }
-  }
-} // namespace names
-
-static std::unordered_map<int64_t, int64_t> module_states;
-static std::mutex                           module_states_mtx;
-
-static std::unordered_map<int64_t, int64_t> resource_states;
-static std::mutex                           resource_states_mtx;
-
-static std::unordered_map<int64_t, int64_t> resource_states_alliance;
-static std::mutex                           resource_states_alliance_mtx;
-
-static std::unordered_map<int64_t, int64_t> slot_states;
-static std::mutex                           slot_states_mtx;
-
-static std::unordered_map<int64_t, size_t> away_assignment_states;
-static std::mutex                          away_assignment_states_mtx;
-
-static std::unordered_map<int64_t, types::PlanetaryBaseState> structure_states;
-static std::mutex                                             structure_states_mtx;
-
-static std::unordered_map<int64_t, int64_t> pieces_states;
-static std::mutex                           pieces_states_mtx;
-
-static eastl::ring_buffer<uint64_t> previously_sent_battlelogs;
-static std::mutex                   previously_sent_battlelogs_mtx;
-
-static void load_previously_sent_logs()
-{
-  using json = nlohmann::json;
-  std::scoped_lock lk(previously_sent_battlelogs_mtx);
-
-  previously_sent_battlelogs.set_capacity(300);
-
-  try {
-    const std::filesystem::path path(File::MakePath(File::Battles()));
-    std::ifstream              file(path, std::ios::in | std::ios::binary);
-    if (!file.is_open()) {
-      spdlog::warn("Failed to open battles file (not found or not readable); starting with empty cache");
-      return;
-    }
-
-    const auto battlelogs = json::parse(file);
-    for (const auto& v : battlelogs) {
-      previously_sent_battlelogs.push_back(v.get<uint64_t>());
-    }
-
-    spdlog::debug("Loaded {} previously sent battle logs", previously_sent_battlelogs.size());
-  } catch (const std::exception& e) {
-    spdlog::error("Failed to parse battles file: {}", e.what());
-  } catch (...) {
-    spdlog::error("Failed to parse battles file");
-  }
-}
-
-static void save_previously_sent_logs()
-{
-  using json           = nlohmann::json;
-  auto battlelog_array = json::array();
-
-  {
-    std::scoped_lock lk(previously_sent_battlelogs_mtx);
-    for (auto id : previously_sent_battlelogs) {
-      battlelog_array.push_back(id);
-    }
-  }
-
-  try {
-    const std::filesystem::path path(File::MakePath(File::Battles(), true));
-    std::ofstream               file(path, std::ios::out | std::ios::binary | std::ios::trunc);
-    if (!file.is_open()) {
-      spdlog::error("Failed to open battles file for writing");
-      return;
-    }
-
-    file << battlelog_array.dump();
-    spdlog::trace("Saved {} previously sent battle logs", battlelog_array.size());
-
-  } catch (const std::exception& e) {
-    spdlog::error("Failed to save battles JSON: {}", e.what());
-  } catch (...) {
-    spdlog::error("Unknown error while saving battles JSON.");
-  }
-}
-} // namespace trackers
-
-namespace fleets
-{
-// Set from any thread when another category's first sync is queued; the game thread answers with a full fleet snapshot.
-static std::atomic_bool snapshot_requested{false};
-
-// Fleets the server just sent new data for. The client fills in some values (mining and travel timers, damage) from
-// that data, so the game thread re-reads these fleets shortly after.
-static std::mutex                                                          reread_mtx;
-static std::unordered_map<uint64_t, std::chrono::steady_clock::time_point> reread_at;
-
-static void request_reread(uint64_t fid)
-{
-  std::scoped_lock lk(reread_mtx);
-  reread_at.try_emplace(fid, std::chrono::steady_clock::now() + std::chrono::seconds(1));
-}
-} // namespace fleets
-
-namespace workers
-{
-
-static std::mutex                                                  sync_data_mtx;
-static std::condition_variable                                     sync_data_cv;
-static std::queue<std::tuple<SyncConfig::Type, std::string, bool>> sync_data_queue;
-
-static std::mutex              combat_log_data_mtx;
-static std::condition_variable combat_log_data_cv;
-static std::queue<uint64_t>    combat_log_data_queue;
-
-static void queue_data(SyncConfig::Type type, const std::string& data, bool is_first_sync = false)
-{
-  {
-    std::scoped_lock lk(sync_data_mtx);
-    sync_data_queue.emplace(type, data, is_first_sync);
-    http::logging::debug("QUEUE", to_string(type), "Added data to sync queue");
-  }
-
-  sync_data_cv.notify_all();
-}
-
-static void queue_data(SyncConfig::Type type, const nlohmann::json& data, bool is_first_sync = false)
-{
-  if (is_first_sync && type != SyncConfig::Type::Fleets) {
-    fleets::snapshot_requested.store(true, std::memory_order_release);
-  }
-
-  {
-    std::scoped_lock lk(sync_data_mtx);
-    sync_data_queue.emplace(type, data.dump(), is_first_sync);
-    http::logging::debug("QUEUE", to_string(type), STR_FORMAT("Added {} entries to sync queue", data.size()));
-  }
-
-  sync_data_cv.notify_all();
-}
-
-static void ship_sync_data()
-{
-#if _WIN32
-  WinRtApartmentGuard apartmentGuard;
-#endif
-
-  try {
-    for (;;) {
-      std::tuple<SyncConfig::Type, std::string, bool> sync_data;
-      {
-        std::unique_lock lock(sync_data_mtx);
-        sync_data_cv.wait(lock, []() { return !sync_data_queue.empty(); });
-        // Move the item out while holding the lock to avoid races/UB
-        sync_data = std::move(sync_data_queue.front());
-        sync_data_queue.pop();
-      }
-
-      try {
-        auto& [type, data, is_first_sync] = sync_data;
-        http::send_data(type, data, is_first_sync);
-      } catch (const std::runtime_error& e) {
-        ErrorMsg::SyncRuntime("ship", e);
-      } catch (const std::exception& e) {
-        ErrorMsg::SyncMsg("ship", e.what());
-      } catch (const std::wstring& sz) {
-        ErrorMsg::SyncMsg("ship", sz);
-#if _WIN32
-      } catch (winrt::hresult_error const& ex) {
-        ErrorMsg::SyncWinRT("ship", ex);
-#endif
-      } catch (...) {
-        ErrorMsg::SyncMsg("ship", "Unknown error during sending of sync data");
-      }
-    }
-  } catch (const std::exception& e) {
-    spdlog::critical("ship_sync_data thread terminated: {}", e.what());
-  } catch (...) {
-    spdlog::critical("ship_sync_data thread terminated: unknown exception");
-  }
-}
-
-static void ship_combat_log_data()
-{
-  using json = nlohmann::json;
-  using namespace trackers::names;
-
-#if _WIN32
-  WinRtApartmentGuard apartmentGuard;
-#endif
-
-  for (;;) {
-    uint64_t journal_id;
-    {
-      std::unique_lock lock(combat_log_data_mtx);
-      combat_log_data_cv.wait(lock, [] { return !combat_log_data_queue.empty(); });
-      // Move the item out while holding the lock to avoid races/UB
-      journal_id = combat_log_data_queue.front();
-      combat_log_data_queue.pop();
-    }
-
-    try {
-      http::logging::trace("PROCESS", "combat log", STR_FORMAT("Fetching combat log for battle {}", journal_id));
-
-      const json journals_body{{"journal_id", journal_id}};
-      auto       battle_log = http::get_scopely_data("/journals/get", journals_body.dump());
-      json       battle_json;
-
-      if (battle_log.empty()) {
-        continue;
-      }
-
-      try {
-        battle_json = std::move(json::parse(battle_log));
-      } catch (const json::exception& e) {
-        spdlog::error("Error parsing journal response from game server: {}", e.what());
-        continue;
-      }
-
-      const auto& journal              = battle_json["journal"];
-      const auto& target_fleet_data    = journal["target_fleet_data"];
-      const auto& initiator_fleet_data = journal["initiator_fleet_data"];
-
-      auto       names      = json::object();
-      const auto now        = std::chrono::steady_clock::now();
-      const auto expires_at = now + std::chrono::seconds(Config::Get().sync_resolver_cache_ttl);
-
-      {
-        std::unordered_set<std::string> user_ids;
-        collect_user_ids_from_fleet(target_fleet_data, user_ids);
-        collect_user_ids_from_fleet(initiator_fleet_data, user_ids);
-        collect_journal_participants(journal, user_ids);
-
-        json profiles_request{{"user_ids", json::array()}};
-        resolve_player_names(user_ids, names, profiles_request["user_ids"], now);
-
-        const auto fetch_count = profiles_request["user_ids"].size();
-        if (fetch_count > 0) {
-          http::logging::trace("PROCESS", "combat log", STR_FORMAT("Fetching {} player profiles", fetch_count));
-
-          auto profiles      = http::get_scopely_data("/user_profile/profiles", profiles_request.dump());
-          auto profiles_json = json::parse(profiles);
-
-          std::scoped_lock lk(player_data_cache_mtx);
-
-          try {
-            for (const auto& [player_id, profile] : profiles_json["user_profiles"].get<json::object_t>()) {
-              const auto& name        = profile["name"].get<std::string>();
-              const auto& alliance_id = profile["alliance_id"].get<int64_t>();
-
-              names[player_id] = {
-                  {"name", name}, {"alliance_id", alliance_id}, {"alliance_name", nullptr}, {"alliance_tag", nullptr}};
-              player_data_cache[player_id] = {.name=name, .alliance=alliance_id, .expires_at=expires_at};
-            }
-          } catch (const json::exception& e) {
-            spdlog::error("Failed to parse user profiles: {}", e.what());
-          }
-        }
-      }
-
-      {
-        std::unordered_set<int64_t> alliance_ids;
-        json alliances_request{{"user_current_rank", 0}, {"alliance_id", 0}, {"alliance_ids", json::array()}};
-
-        collect_alliance_ids(names, alliance_ids);
-        resolve_alliance_names(alliance_ids, names, alliances_request["alliance_ids"], now);
-
-        const auto fetch_count = alliances_request["alliance_ids"].size();
-        if (fetch_count > 0) {
-          http::logging::trace("PROCESS", "combat log", STR_FORMAT("Fetching {} alliance profiles", fetch_count));
-
-          auto profiles      = http::get_scopely_data("/alliance/get_alliances_public_info", alliances_request.dump());
-          auto profiles_json = json::parse(profiles);
-
-          std::scoped_lock lk(alliance_data_cache_mtx);
-
-          try {
-            for (const auto& [alliance_id_str, profile] : profiles_json["alliances_info"].get<json::object_t>()) {
-              const auto  id   = profile["id"].get<int64_t>();
-              const auto& name = profile["name"].get<std::string>();
-              const auto& tag  = profile["tag"].get<std::string>();
-
-              alliance_data_cache[id] = {.name=name, .tag=tag, .expires_at=expires_at};
-            }
-          } catch (json::exception& e) {
-            spdlog::error("Failed to parse alliance profiles: {}", e.what());
-          }
-
-          for (const auto& [player_id, entry] : names.items()) {
-            try {
-              if (entry.contains("alliance_id")) {
-                const auto alliance_id = entry["alliance_id"].get<int64_t>();
-                const auto it          = alliance_data_cache.find(alliance_id);
-                if (it != alliance_data_cache.end()) {
-                  entry["alliance_name"] = it->second.name;
-                  entry["alliance_tag"]  = it->second.tag;
-                  entry.erase("alliance_id");
-                }
-              }
-            } catch (json::exception& e) {
-              spdlog::error("Failed to update cached player data: {}", e.what());
-            }
-          }
-        }
-      }
-
-      auto battle_array = json::array();
-      battle_array.push_back(
-          {{"type", SyncConfig::Type::Battles}, {"names", names}, {"journal", battle_json["journal"]}});
-
-      try {
-        auto ship_data = battle_array.dump();
-        http::send_data(SyncConfig::Type::Battles, ship_data, false);
-      } catch (const std::runtime_error& e) {
-        ErrorMsg::SyncRuntime("combat", e);
-      } catch (const std::exception& e) {
-        ErrorMsg::SyncException("combat", e);
-      } catch (const std::wstring& sz) {
-        ErrorMsg::SyncMsg("combat", sz);
-#if _WIN32
-      } catch (winrt::hresult_error const& ex) {
-        ErrorMsg::SyncWinRT("combat", ex);
-#endif
-      } catch (...) {
-        ErrorMsg::SyncMsg("combat", "Unknown error during sending of sync data");
-      }
-
-    } catch (json::exception& e) {
-      spdlog::error("Error parsing combat log or profiles: {}", e.what());
-    } catch (std::exception& e) {
-      spdlog::error("Error processing combat log: {}", e.what());
-    } catch (...) {
-      spdlog::error("Unknown error during processing of combat log data");
-    }
-  }
-}
-
-} // namespace workers
-
-namespace processors
-{
-
-// Builds the sync event for one away team assignment instance and appends it to `out_array` only if the
-// instance's observable state changed since the last time it was emitted. Caller must hold
-// trackers::away_assignment_states_mtx.
-static void away_assignment_event(const Digit::PrimeServer::Models::AwayAssignmentInstance& instance,
-                                  nlohmann::json&                                           out_array)
-{
-  using json = nlohmann::json;
-  using trackers::away_assignment_states;
-
-  // Protobuf map iteration order is not guaranteed to match slot order, so sort by slot index
-  // before emitting officer_ids to keep the array (and therefore the de-dup hash) stable.
-  std::vector<std::pair<int64_t, int64_t>> officer_slots(instance.officerids().begin(), instance.officerids().end());
-  std::ranges::sort(officer_slots, {}, &std::pair<int64_t, int64_t>::first);
-
-  auto officer_ids = json::array();
-  for (const auto& [slot, officer_id] : officer_slots) {
-    if (officer_id != 0) {
-      officer_ids.push_back(officer_id);
-    }
-  }
-
-  auto officer_traits = json::array();
-  for (const auto& trait : instance.officertraits()) {
-    officer_traits.push_back({{"tid", trait.traitid()}, {"max_level", trait.maxlevel()}});
-  }
-
-  // Same ordering concern as officer_ids: sort by trait id so the array and the de-dup hash are stable.
-  std::vector<std::pair<int64_t, int32_t>> critical_trait_pairs(instance.parameters().criticaltraitscores().begin(),
-                                                                instance.parameters().criticaltraitscores().end());
-  std::ranges::sort(critical_trait_pairs, {}, &std::pair<int64_t, int32_t>::first);
-
-  auto critical_trait_scores = json::array();
-  for (const auto& [tid, score] : critical_trait_pairs) {
-    critical_trait_scores.push_back({{"tid", tid}, {"score", score}});
-  }
-
-  json event = {{"type", SyncConfig::Type::AwayAssignments},
-                {"aid", instance.id()},
-                {"template_id", instance.awayassignmenttemplateid()},
-                {"state", instance.state()},
-                {"officer_ids", officer_ids},
-                {"job_uuid", instance.jobuuid()},
-                {"duration", instance.parameters().duration()},
-                {"rarity", instance.rarity()},
-                {"officer_traits", officer_traits},
-                {"critical_trait_scores", critical_trait_scores},
-                {"success_chance", instance.parameters().successchance()},
-                {"critical_success_chance", instance.parameters().criticalsuccesschance()},
-                {"max_critical_success_chance", instance.maxcriticalsuccesschance()},
-                {"key_stat", instance.keystat()},
-                {"max_assignable_officers", instance.maxassignableofficerscount()},
-                {"attack_weight", instance.attackweight()},
-                {"defense_weight", instance.defenseweight()},
-                {"health_weight", instance.healthweight()}};
-
-  const auto state_value = std::hash<json>{}(event);
-
-  if (const auto& it = away_assignment_states.find(instance.id());
-      it == away_assignment_states.end() || it->second != state_value) {
-    away_assignment_states[instance.id()] = state_value;
-    out_array.push_back(std::move(event));
-  }
-}
-
-static void away_assignments_list(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  static std::atomic_bool is_first_sync{true};
-
-  if (auto response = Digit::PrimeServer::Models::AwayAssignmentUserListResponse(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "away assignments",
-                         STR_FORMAT("Processing {} away assignments", response.instances_size()));
-
-    std::unordered_set<int64_t> ids_in_response;
-    ids_in_response.reserve(static_cast<size_t>(response.instances_size()));
-    auto assignment_array = json::array();
-
-    {
-      std::scoped_lock lk(trackers::away_assignment_states_mtx);
-
-      for (const auto& instance : response.instances()) {
-        ids_in_response.insert(instance.id());
-        away_assignment_event(instance, assignment_array);
-      }
-
-      // Prune entries that are no longer present to prevent unbounded growth
-      for (auto it = trackers::away_assignment_states.begin(); it != trackers::away_assignment_states.end();) {
-        if (!ids_in_response.contains(it->first)) {
-          assignment_array.push_back({{"type", "collected_" + SyncConfig::Type::AwayAssignments}, {"aid", it->first}});
-          it = trackers::away_assignment_states.erase(it);
-        } else {
-          ++it;
-        }
-      }
-    }
-
-    if (!assignment_array.empty()) {
-      const bool first_sync = is_first_sync.exchange(false, std::memory_order_acq_rel);
-      workers::queue_data(SyncConfig::Type::AwayAssignments, assignment_array, first_sync);
-    }
-  } else {
-    spdlog::error("Failed to parse away assignments");
-  }
-}
-
-static void away_assignment_instance(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-
-  if (auto instance = Digit::PrimeServer::Models::AwayAssignmentInstance(); instance.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "away assignment instance",
-                         STR_FORMAT("Processing away assignment {}", instance.id()));
-
-    auto assignment_array = json::array();
-    {
-      std::scoped_lock lk(trackers::away_assignment_states_mtx);
-      away_assignment_event(instance, assignment_array);
-    }
-
-    if (!assignment_array.empty()) {
-      workers::queue_data(SyncConfig::Type::AwayAssignments, assignment_array);
-    }
-  } else {
-    spdlog::error("Failed to parse away assignment instance");
-  }
-}
-
-static void queue_battle_ids(const std::vector<uint64_t>& battle_ids)
-{
-  std::vector<uint64_t> to_enqueue;
-  {
-    using trackers::previously_sent_battlelogs;
-    using trackers::previously_sent_battlelogs_mtx;
-
-    std::scoped_lock lk(previously_sent_battlelogs_mtx);
-
-    for (const auto id : battle_ids | std::views::reverse) {
-      if (eastl::find(previously_sent_battlelogs.begin(), previously_sent_battlelogs.end(), id)
-          == previously_sent_battlelogs.end()) {
-        previously_sent_battlelogs.push_back(id);
-        to_enqueue.push_back(id);
-      }
-    }
-  }
-
-  if (!to_enqueue.empty()) {
-    http::logging::debug("QUEUE", "battle headers",
-                         STR_FORMAT("Queuing {} battles for background processing", to_enqueue.size()));
-
-    {
-      std::scoped_lock lk(workers::combat_log_data_mtx);
-      for (const auto id : to_enqueue) {
-        workers::combat_log_data_queue.push(id);
-      }
-    }
-
-    trackers::save_previously_sent_logs();
-    workers::combat_log_data_cv.notify_all();
-  }
-}
-
-static void battle_result_headers(std::unique_ptr<std::string>&& bytes)
-{
-  if (auto response = Digit::PrimeServer::Models::BattleResultHeadersResponse(); response.ParseFromString(*bytes)) {
-    http::logging::trace("PROCESS", "battle headers",
-                         STR_FORMAT("Processing {} battle headers", response.headers_size()));
-
-    std::vector<uint64_t> battle_ids;
-    battle_ids.reserve(static_cast<size_t>(response.headers_size()));
-
-    for (const auto& header : response.headers()) {
-      battle_ids.push_back(static_cast<uint64_t>(header.id()));
-    }
-
-    queue_battle_ids(battle_ids);
-  } else {
-    spdlog::error("Failed to parse battle result headers");
-  }
-}
-
-struct ShipRecord {
-  int64_t              id;
-  int64_t              hull_id;
-  int32_t              tier;
-  int32_t              level;
-  double               level_percentage;
-  std::vector<int64_t> components;
-};
-
-static void sync_ships(const std::vector<ShipRecord>& ships)
-{
-  using json = nlohmann::json;
-  using trackers::types::ShipState;
-
-  static std::unordered_map<int64_t, ShipState> ship_states;
-  static std::mutex                             ship_states_mtx;
-  static std::atomic_bool                       is_first_sync{true};
-
-  auto ship_array = json::array();
-  {
-    std::scoped_lock lk(ship_states_mtx);
-
-    for (const auto& ship : ships) {
-      const ShipState state{ship.tier, ship.level, ship.level_percentage, ship.components};
-
-      if (const auto& it = ship_states.find(ship.id); it == ship_states.end() || it->second != state) {
-        ship_states[ship.id] = state;
-        ship_array.push_back({{"type", SyncConfig::Type::Ships},
-                              {"psid", ship.id},
-                              {"level", ship.level},
-                              {"level_percentage", ship.level_percentage},
-                              {"tier", ship.tier},
-                              {"hull_id", ship.hull_id},
-                              {"components", ship.components}});
-      }
-    }
-  }
-
-  if (!ship_array.empty()) {
-    const bool first_sync = is_first_sync.exchange(false, std::memory_order_acq_rel);
-    workers::queue_data(SyncConfig::Type::Ships, ship_array, first_sync);
-  }
-}
-
-static void player_ships(std::unique_ptr<std::string>&& bytes)
-{
-  if (auto response = Digit::PrimeServer::Models::PlayerShipsResponse(); response.ParseFromString(*bytes)) {
-    http::logging::trace("PROCESS", "ships", STR_FORMAT("Processing {} ships", response.ships_size()));
-
-    std::vector<ShipRecord> ships;
-    ships.reserve(static_cast<size_t>(response.ships_size()));
-
-    for (const auto& ship : response.ships() | std::views::values) {
-      ships.push_back({ship.id(), ship.hullid(), ship.tier(), ship.level(), ship.levelpercentage(),
-                       std::vector<int64_t>(ship.components().begin(), ship.components().end())});
-    }
-
-    sync_ships(ships);
-  } else {
-    spdlog::error("Failed to parse player ships");
-  }
-}
-
-static void battle_report(std::unique_ptr<std::string>&& bytes)
-{
-  // TODO: Placeholder for future client support; currently unused by the game client.
-  spdlog::debug("process_battle_report() was called");
-}
-
-static void global_active_buffs(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  static std::unordered_map<int64_t, std::pair<int32_t, int64_t>> buff_states;
-  static std::mutex                                               buff_states_mtx;
-  static std::atomic_bool                                         is_first_sync{true};
-
-  if (auto response = Digit::PrimeServer::Models::GlobalActiveBuffsResponse(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "global buffs",
-                         STR_FORMAT("Processing {} active buffs", response.globalactivebuffs_size()));
-
-    auto buff_array = json::array();
-    {
-      std::scoped_lock lk(buff_states_mtx);
-
-      // Track all buff ids present in the response to detect removals.
-      std::unordered_set<int64_t> present_ids;
-      present_ids.reserve(static_cast<size_t>(response.globalactivebuffs_size()));
-
-      for (const auto& buff : response.globalactivebuffs()) {
-        present_ids.insert(buff.buffid());
-        const bool expires = buff.has_activebuff() && buff.activebuff().has_expirytime();
-        const auto state   = std::make_pair(buff.level(), expires ? buff.activebuff().expirytime().seconds() : -1);
-
-        if (const auto& it = buff_states.find(buff.buffid()); it == buff_states.end() || it->second != state) {
-          buff_states[buff.buffid()] = state;
-          buff_array.push_back({{"type", SyncConfig::Type::Buffs},
-                                {"bid", buff.buffid()},
-                                {"level", state.first},
-                                {"expiry_time", expires ? json(state.second) : json(nullptr)}});
-        }
-      }
-
-      // Remove buffs that are no longer present and record each removal.
-      for (auto it = buff_states.begin(); it != buff_states.end();) {
-        if (!present_ids.contains(it->first)) {
-          buff_array.push_back({
-              {"type", "expired_" + SyncConfig::Type::Buffs},
-              {"bid", it->first},
-          });
-          it = buff_states.erase(it);
-        } else {
-          ++it;
-        }
-      }
-    }
-
-    if (!buff_array.empty()) {
-      const bool first_sync = is_first_sync.exchange(false, std::memory_order_acq_rel);
-      workers::queue_data(SyncConfig::Type::Buffs, buff_array, first_sync);
-    }
-  } else {
-    spdlog::error("Failed to parse global active buffs");
-  }
-}
-
-static void alliance_games_props(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  static std::atomic_int32_t emerald_chain_level{-1};
-
-  if (auto response = Digit::PrimeServer::Models::AllianceGamePropertiesResponse(); response.ParseFromString(*bytes)) {
-
-    for (const auto& prop : response.properties()) {
-      if (prop.propertyname() == "claimed_loyalty_tiers") {
-        const auto& claimed_ec_levels = prop.valuelist();
-        const auto& max_element =
-            std::ranges::max_element(claimed_ec_levels, {}, [](const auto& level) { return std::stoi(level); });
-        const auto ec_level = max_element != claimed_ec_levels.end() ? std::stoi(*max_element) : -1;
-
-        int32_t current_level = emerald_chain_level.load();
-        if (ec_level != current_level && emerald_chain_level.compare_exchange_strong(current_level, ec_level)) {
-          auto ag_array = json::array();
-          ag_array.push_back({{"type", SyncConfig::Type::EmeraldChain}, {"level", ec_level}});
-          workers::queue_data(SyncConfig::Type::EmeraldChain, ag_array);
-        }
-
-        break;
-      }
-    }
-  } else {
-    spdlog::error("Failed to parse alliance games properties");
-  }
-}
-
-static void starbase_modules(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  using trackers::module_states;
-  using trackers::module_states_mtx;
-
-  if (auto response = Digit::PrimeServer::Models::StarbaseModulesResponse(); response.ParseFromString(*bytes)) {
-    http::logging::trace("PROCESS", "starbase modules", STR_FORMAT("Processing {} buildings", response.modulestates_size()));
-
-    auto starbase_array = json::array();
-    {
-      std::scoped_lock lk(module_states_mtx);
-
-      for (const auto& module : response.modulestates()) {
-        if (const auto& it = module_states.find(module.id()); it == module_states.end() || it->second != module.level()) {
-          module_states[module.id()] = module.level();
-          starbase_array.push_back({{"type", SyncConfig::Type::Buildings}, {"bid", module.id()}, {"level", module.level()}});
-        }
-      }
-    }
-
-    if (!starbase_array.empty()) {
-      workers::queue_data(SyncConfig::Type::Buildings, starbase_array);
-    }
-  } else {
-    spdlog::error("Failed to parse resources");
-  }
-}
-
-static void planetary_base_data(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  using trackers::pieces_states;
-  using trackers::pieces_states_mtx;
-
-  static std::atomic_bool is_first_sync{true};
-
-  if (auto response = Digit::PrimeServer::Models::PlanetaryBase(); response.ParseFromString(*bytes)) {
-    http::logging::trace("PROCESS", "planetary base data", STR_FORMAT("Processing {} haven building pieces", response.pieces_size()));
-    auto pieces_array = json::array();
-    {
-      std::scoped_lock lk(pieces_states_mtx);
-
-      for (const auto& [piece, count] : response.pieces()) {
-        if (const auto& it = pieces_states.find(piece); it == pieces_states.end() || it->second != count) {
-          pieces_states[piece] = count;
-          pieces_array.push_back({{"type", SyncConfig::Type::Haven + "_pieces"}, {"sid", piece}, {"count", count}});
-        }
-      }
-    }
-
-    if (!pieces_array.empty()) {
-      const bool first_sync = is_first_sync.exchange(false, std::memory_order_acq_rel);
-      workers::queue_data(SyncConfig::Type::Haven, pieces_array, first_sync);
-    }
-  }
-}
-
-static void planetary_map_building_data(const google::protobuf::Map<int64_t, Digit::PrimeServer::Models::PlanetaryMapData_BuildingData>& buildings)
-{
-  using trackers::structure_states;
-  using trackers::structure_states_mtx;
-  using trackers::types::PlanetaryBaseState;
-
-  static std::atomic_bool is_first_sync{true};
-
-  auto structure_array = nlohmann::json::array();
-  {
-    std::scoped_lock lk(structure_states_mtx);
-
-    for (const auto& [id, building] : buildings) {
-      const PlanetaryBaseState state{building.level(), building.status(), building.position()};
-
-      if (const auto& it = structure_states.find(id); it == structure_states.end() || it->second != state) {
-        structure_states[id] = state;
-        structure_array.push_back({{"type", SyncConfig::Type::Haven}, {"sid", building.specid()}, {"id", id}, {"level", building.level()}, {"status", building.status()}, {"position", building.position()}});
-      }
-    }
-  }
-
-  if (!structure_array.empty()) {
-    const bool first_sync = is_first_sync.exchange(false, std::memory_order_acq_rel);
-    workers::queue_data(SyncConfig::Type::Haven, structure_array, first_sync);
-  }
-}
-
-static void planetary_map_data(std::unique_ptr<std::string>&& bytes)
-{
-  if (auto response = Digit::PrimeServer::Models::PlanetaryMapData(); response.ParseFromString(*bytes)) {
-    http::logging::trace("PROCESS", "planetary map data", STR_FORMAT("Processing {} buildings", response.buildings_size()));
-    planetary_map_building_data(response.buildings());
-  }
-}
-
-static void planetary_map_prosperity(std::unique_ptr<std::string>&& bytes)
-{
-  if (auto response = Digit::PrimeServer::Models::PlanetaryMapProsperityResponse(); response.ParseFromString(*bytes)) {
-    http::logging::trace("PROCESS", "planetary map prosperity", STR_FORMAT("Processing prosperity={}", response.prosperity()));
-    const auto prosperity_array = nlohmann::json::array(
-        {{{"type", SyncConfig::Type::Haven + "_prosperity"}, {"prosperity", response.prosperity()}}});
-    workers::queue_data(SyncConfig::Type::Haven, prosperity_array);
-  }
-}
-
-// The game's record of the local player, or nullptr. Calls into IL2CPP: game thread only.
-static UserProfile* local_user_profile()
-{
-  auto* const manager = UserProfileManager::Instance();
-  if (manager == nullptr) {
-    return nullptr;
-  }
-
-  return manager->GetLocalUserProfile();
-}
-
-static void planetary_map(std::unique_ptr<std::string>&& bytes)
-{
-  if (auto response = Digit::PrimeServer::Models::PlanetaryMapResponse(); response.ParseFromString(*bytes)) {
-    http::logging::trace("PROCESS", "planetary map", STR_FORMAT("Processing {} haven structures", response.mapdata().buildings_size()));
-
-    const auto& owner = response.owneruserid();
-    if (!owner.empty()) {
-      auto* localProfile = local_user_profile();
-      if (localProfile == nullptr) {
-        spdlog::error("Failed to get local user profile");
-        return;
-      }
-
-      const auto userId = localProfile->UserId();
-      if (userId == nullptr) {
-        spdlog::error("Local user profile has empty UserId");
-        return;
-      }
-
-      if (owner != to_string(userId)) {
-        spdlog::debug("Planetary map data is not for local user, skipping processing");
-        return;
-      }
-    }
-
-    planetary_map_building_data(response.mapdata().buildings());
-  } else {
-    spdlog::error("Failed to parse planetary map");
-  }
-}
-
-// The local player's user id, or "" if the profile is not available. Game thread only.
-static std::string local_user_id(UserProfile* profile)
-{
-  if (profile == nullptr) {
-    return {};
-  }
-
-  auto* const user_id = profile->UserId();
-  return user_id == nullptr ? std::string{} : to_string(user_id);
-}
-
-// Sends the local player's own profile; `self` and `level` come from the game thread. Only the record whose user id
-// is `self` is read. The server record carries level 0, so the in-memory Level is used: it lags one own-record
-// response after a level-up.
-static void own_profile(std::unique_ptr<std::string>&& bytes, const std::string& self, int32_t level)
-{
-  using json = nlohmann::json;
-
-  static std::tuple<int32_t, uint64_t, bool> last_sent;
-  static bool                                has_sent = false;
-  static std::mutex                          last_sent_mtx;
-
-  auto response = Digit::PrimeServer::Models::UserProfilesResponse();
-  if (!response.ParseFromString(*bytes)) {
-    spdlog::error("Failed to parse own user profile");
-    return;
-  }
-
-  const Digit::PrimeServer::Models::UserProfile* own = nullptr;
-  for (const auto& profile : response.userprofiles()) {
-    if (profile.userid() == self) {
-      own = &profile;
-      break;
-    }
-  }
-
-  if (own == nullptr) {
-    return;
-  }
-
-  // XP rides along but is not part of the key: an XP-only change waits for the next keyed change.
-  const auto key = std::make_tuple(level, own->militarymight(), own->planetarybaseunlocked());
-  bool       first_sync;
-  {
-    std::scoped_lock lk(last_sent_mtx);
-    first_sync = !has_sent;
-    if (!first_sync && last_sent == key) {
-      return;
-    }
-    last_sent = key;
-    has_sent  = true;
-  }
-
-  auto profile_array = json::array();
-  profile_array.push_back({{"type", SyncConfig::Type::Profile},
-                           {"uid", self},
-                           {"level", level},
-                           {"xp", own->xp()},
-                           {"military_might", own->militarymight()},
-                           {"planetary_base_unlocked", own->planetarybaseunlocked()}});
-
-  workers::queue_data(SyncConfig::Type::Profile, profile_array, first_sync);
-}
-
-static void player_inventories(std::unique_ptr<std::string>&& bytes)
-{
-  using json   = nlohmann::json;
-  using trackers::types::pairhash;
-  using item_t = std::underlying_type_t<Digit::PrimeServer::Models::InventoryItemType>;
-
-  static std::unordered_map<std::pair<item_t, int64_t>, int64_t, pairhash> inventory_states;
-  static std::mutex                                                        inventory_states_mtx;
-  static std::atomic_bool                                                  is_first_sync{true};
-
-  if (auto response = Digit::PrimeServer::Models::InventoryResponse(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "player inventories",
-                         STR_FORMAT("Processing {} inventories", response.inventories_size()));
-
-    auto inventory_items = json::array();
-    {
-      std::scoped_lock lk(inventory_states_mtx);
-
-      for (const auto& inventory : response.inventories() | std::views::values) {
-        for (const auto& item : inventory.items()) {
-          if (item.has_commonparams()) {
-            const auto item_id = item.commonparams().refid();
-            const auto count   = item.count();
-            const auto key     = std::make_pair(item.type(), item_id);
-
-            if (const auto& it = inventory_states.find(key); it == inventory_states.end() || it->second != count) {
-              inventory_states[key] = count;
-              inventory_items.push_back({{"type", SyncConfig::Type::Inventory},
-                                         {"item_type", item.type()},
-                                         {"refid", item_id},
-                                         {"count", count}});
-            }
-          }
-        }
-      }
-    }
-
-    if (!inventory_items.empty()) {
-      const bool first_sync = is_first_sync.exchange(false, std::memory_order_acq_rel);
-      workers::queue_data(SyncConfig::Type::Inventory, inventory_items, first_sync);
-    }
-  } else {
-    spdlog::error("Failed to parse player inventories");
-  }
-}
-
-static void jobs(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  using job_state = std::tuple<int64_t, int64_t, int64_t>;
-  static std::unordered_map<std::string, job_state> jobs_active;
-  static std::mutex                                 jobs_active_mtx;
-  static std::atomic_bool                           is_first_sync{true};
-
-  if (auto response = Digit::PrimeServer::Models::JobResponse(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "jobs", STR_FORMAT("Processing {} jobs", response.jobs_size()));
-
-    std::unordered_set<std::string> uuids_in_response;
-    uuids_in_response.reserve(response.jobs_size());
-    auto job_array = json::array();
-
-    for (const auto& job : response.jobs()) {
-      const std::string& uuid = job.uuid();
-      uuids_in_response.insert(uuid);
-
-      const job_state state{job.starttime().seconds(), job.duration(), job.reductioninseconds()};
-
-      bool emit = false;
-      {
-        std::scoped_lock lk(jobs_active_mtx);
-        const auto [it, inserted] = jobs_active.try_emplace(uuid, state);
-        emit                      = inserted || it->second != state;
-        it->second                = state;
-      }
-
-      if (!emit) {
-        continue;
-      }
-
-      json job_params;
-
-      switch (job.type()) {
-        case Digit::PrimeServer::Models::JOBTYPE_RESEARCH: {
-          const auto& research = job.researchparams();
-          job_params           = {{"rid", research.projectid()}, {"level", research.level()}};
-        } break;
-        case Digit::PrimeServer::Models::JOBTYPE_STARBASECONSTRUCTION: {
-          const auto& construction = job.starbaseconstructionparams();
-          job_params               = {{"bid", construction.moduleid()}, {"level", construction.level()}};
-        } break;
-        case Digit::PrimeServer::Models::JOBTYPE_SHIPTIERUP: {
-          const auto& upgrade = job.tierupshipparams();
-          job_params          = {{"psid", upgrade.shipid()}, {"tier", upgrade.newtier()}};
-        } break;
-        case Digit::PrimeServer::Models::JOBTYPE_SHIPSCRAP: {
-          const auto& scrap = job.scrapyardparams();
-          job_params        = {{"psid", scrap.shipid()}, {"hull_id", scrap.hullid()}, {"level", scrap.level()}};
-        } break;
-        case Digit::PrimeServer::Models::JOBTYPE_AWAYASSIGNMENT: {
-          const auto& away_assignment = job.awayassignmentparams();
-          job_params                  = {{"aid", away_assignment.awayassignmentinstanceid()}};
-        } break;
-        case Digit::PrimeServer::Models::JOBTYPE_REPAIRFLEET: {
-          // part of fleet sync
-          if (!Config::Get().sync_options.fleets) {
-            continue;
-          }
-          job_params = {{"fid", job.repairfleetparams().fleetid()}};
-          fleets::request_reread(job.repairfleetparams().fleetid());
-        } break;
-        default:
-          continue;
-      }
-
-      json job_data = json::object({{"type", SyncConfig::Type::Jobs},
-                                    {"job_type", job.type()},
-                                    {"uuid", job.uuid()},
-                                    {"start_time", job.starttime().seconds()},
-                                    {"duration", job.duration()},
-                                    {"reduction", job.reductioninseconds()}});
-
-      job_data.update(job_params);
-      job_array.push_back(std::move(job_data));
-    }
-
-    // Prune entries that are no longer present to prevent unbounded growth
-    {
-      std::scoped_lock lk(jobs_active_mtx);
-      for (auto it = jobs_active.begin(); it != jobs_active.end();) {
-        if (!uuids_in_response.contains(it->first)) {
-          job_array.push_back({{"type", "completed_" + SyncConfig::Type::Jobs}, {"uuid", it->first}});
-          it = jobs_active.erase(it);
-        } else {
-          ++it;
-        }
-      }
-    }
-
-    if (!job_array.empty()) {
-      const bool first_sync = is_first_sync.exchange(false, std::memory_order_acq_rel);
-      workers::queue_data(SyncConfig::Type::Jobs, job_array, first_sync);
-    }
-  } else {
-    spdlog::error("Failed to parse jobs");
-  }
-}
-
-static void active_missions(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  static std::unordered_set<int64_t> active_mission_states;
-  static std::mutex                  active_mission_states_mtx;
-
-  if (auto response = Digit::PrimeServer::Models::ActiveMissionsResponse(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "active missions",
-                         STR_FORMAT("Processing {} active missions", response.activemissions_size()));
-
-    std::unordered_set<int64_t> active_missions;
-    for (const auto& mission : response.activemissions()) {
-      active_missions.insert(mission.id());
-    }
-
-    bool changed = false;
-    {
-      std::scoped_lock lk(active_mission_states_mtx);
-      if (active_mission_states != active_missions) {
-        changed               = true;
-        active_mission_states = std::move(active_missions);
-      }
-    }
-
-    if (changed && !active_mission_states.empty()) {
-      auto mission_array = json::array();
-
-      for (const auto mission : active_mission_states) {
-        mission_array.push_back({{"type", "active_" + SyncConfig::Type::Missions}, {"mid", mission}});
-      }
-
-      workers::queue_data(SyncConfig::Type::Missions, mission_array);
-    }
-  } else {
-    spdlog::error("Failed to parse active missions");
-  }
-}
-
-static void completed_missions(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  static std::vector<int64_t> completed_mission_states;
-  static std::mutex           completed_mission_states_mtx;
-
-  if (auto response = Digit::PrimeServer::Models::CompletedMissionsResponse(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "completed missions",
-                         STR_FORMAT("Processing {} completed missions", response.completedmissions_size()));
-
-    const auto&          missions = response.completedmissions();
-    std::vector<int64_t> completed_missions{missions.begin(), missions.end()};
-    std::vector<int64_t> diff;
-
-    // Assume the completed missions list is append-only: new entries may be added, but existing ones are never removed.
-    {
-      std::scoped_lock lk(completed_mission_states_mtx);
-      std::ranges::set_difference(completed_missions, completed_mission_states, std::back_inserter(diff));
-
-      if (!diff.empty()) {
-        completed_mission_states = std::move(completed_missions);
-      }
-    }
-
-    if (!diff.empty()) {
-      auto mission_array = json::array();
-
-      for (const auto mission : diff) {
-        mission_array.push_back({{"type", SyncConfig::Type::Missions}, {"mid", mission}});
-      }
-
-      workers::queue_data(SyncConfig::Type::Missions, mission_array);
-    }
-  } else {
-    spdlog::error("Failed to parse completed missions");
-  }
-}
-
-static void officers(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  using trackers::types::RankLevelShardsState;
-
-  static std::unordered_map<uint64_t, RankLevelShardsState> officer_states;
-  static std::mutex                                         officer_states_mtx;
-
-  if (auto response = Digit::PrimeServer::Models::OfficersResponse(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "officers", STR_FORMAT("Processing {} officers", response.officers_size()));
-
-    auto officers_array = json::array();
-    {
-      std::scoped_lock lk(officer_states_mtx);
-
-      for (const auto& officer : response.officers()) {
-        const RankLevelShardsState officer_state{officer.rankindex(), officer.level(), officer.shardcount()};
-
-        if (const auto& it = officer_states.find(officer.id());
-            it == officer_states.end() || it->second != officer_state) {
-          officer_states[officer.id()] = officer_state;
-          officers_array.push_back({{"type", SyncConfig::Type::Officer},
-                                    {"oid", officer.id()},
-                                    {"rank", officer.rankindex()},
-                                    {"level", officer.level()},
-                                    {"shard_count", officer.shardcount()}});
-            }
-      }
-    }
-
-    if (!officers_array.empty()) {
-      workers::queue_data(SyncConfig::Type::Officer, officers_array);
-    }
-  } else {
-    spdlog::error("Failed to parse officers");
-  }
-}
-
-static void research_trees_state(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  static std::unordered_map<int64_t, int32_t> research_states;
-  static std::mutex                           research_states_mtx;
-
-  if (auto response = Digit::PrimeServer::Models::ResearchTreesState(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "research trees state",
-                         STR_FORMAT("Processing {} research projects", response.researchprojectlevels_size()));
-
-    auto research_array = json::array();
-    {
-      std::scoped_lock lk(research_states_mtx);
-
-      for (const auto& [id, level] : response.researchprojectlevels()) {
-        if (const auto& it = research_states.find(id); it == research_states.end() || it->second != level) {
-          research_states[id] = level;
-          research_array.push_back({{"type", SyncConfig::Type::Research}, {"rid", id}, {"level", level}});
-        }
-      }
-    }
-
-    if (!research_array.empty()) {
-      workers::queue_data(SyncConfig::Type::Research, research_array);
-    }
-  } else {
-    spdlog::error("Failed to parse research trees state");
-  }
-}
-
-static void resources(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  using trackers::resource_states;
-  using trackers::resource_states_mtx;
-  static std::atomic_bool is_first_sync{true};
-
-  if (auto response = Digit::PrimeServer::Models::ResourcesResponse(); response.ParseFromString(*bytes)) {
-    http::logging::trace("PROCESS", "resources", STR_FORMAT("Processing {} resources", response.resources_size()));
-
-    auto resource_array = json::array();
-    {
-      std::scoped_lock lk(resource_states_mtx);
-
-      for (const auto& resource : response.resources()) {
-        if (const auto& it = resource_states.find(resource.id()); it == resource_states.end() || it->second != resource.currentamount()) {
-          resource_states[resource.id()] = resource.currentamount();
-          resource_array.push_back({{"type", SyncConfig::Type::Resources}, {"rid", resource.id()}, {"amount", resource.currentamount()}});
-        }
-      }
-    }
-
-    if (!resource_array.empty()) {
-      const bool first_sync = is_first_sync.exchange(false, std::memory_order_acq_rel);
-      workers::queue_data(SyncConfig::Type::Resources, resource_array, first_sync);
-    }
-  } else {
-    spdlog::error("Failed to parse resources");
-  }
-}
-
-static void resources_delta(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  using trackers::resource_states;
-  using trackers::resource_states_mtx;
-
-  if (auto response = Digit::PrimeServer::Models::ResourcesDeltaResponse(); response.ParseFromString(*bytes)) {
-    http::logging::trace("PROCESS", "resources_delta", STR_FORMAT("Processing {} resource changes", response.resources_size()));
-
-    auto resource_array = json::array();
-    {
-      std::scoped_lock lk(resource_states_mtx);
-
-      for (const auto& resource : response.resources()) {
-        if (const auto& it = resource_states.find(resource.id()); it == resource_states.end() || it->second != resource.amount()) {
-          resource_states[resource.id()] = resource.amount();
-          resource_array.push_back({{"type", SyncConfig::Type::Resources}, {"rid", resource.id()}, {"amount", resource.amount()}});
-        }
-      }
-    }
-
-    if (!resource_array.empty()) {
-      workers::queue_data(SyncConfig::Type::Resources, resource_array);
-    }
-
-  } else {
-    spdlog::error("Failed to parse resources delta");
-  }
-}
-
-static void alliance_resources(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  using trackers::resource_states_alliance;
-  using trackers::resource_states_alliance_mtx;
-  static std::atomic_bool is_first_sync{true};
-
-  if (auto response = Digit::PrimeServer::Models::AllianceGetBankResourcesResponse(); response.ParseFromString(*bytes)) {
-    http::logging::trace("PROCESS", "alliance_resources", STR_FORMAT("Processing {} alliance resources", response.items_size()));
-
-    auto resource_array = json::array();
-    {
-      std::scoped_lock lk(resource_states_alliance_mtx);
-
-      for (const auto& item : response.items()) {
-        if (item.has_commonparams()) {
-          const auto id = item.commonparams().refid();
-          const auto amount   = item.count();
-
-          if (const auto& it = resource_states_alliance.find(id); it == resource_states_alliance.end() || it->second != amount) {
-            resource_states_alliance[id] = amount;
-            resource_array.push_back({{"type", "alliance_" + SyncConfig::Type::Resources}, {"rid", id}, {"amount", amount}});
-          }
-        }
-      }
-    }
-
-    if (!resource_array.empty()) {
-      const bool first_sync = is_first_sync.exchange(false, std::memory_order_acq_rel);
-      workers::queue_data(SyncConfig::Type::Resources, resource_array, first_sync);
-    }
-  } else {
-    spdlog::error("Failed to parse alliance resources");
-  }
-}
-
-static void alliance_resources_delta(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  using trackers::resource_states_alliance;
-  using trackers::resource_states_alliance_mtx;
-
-  if (auto response = Digit::PrimeServer::Models::AllianceResourcesDeltaResponse(); response.ParseFromString(*bytes)) {
-    http::logging::trace("PROCESS", "alliance_resources_delta", STR_FORMAT("Processing {} alliance resource changes", response.resources_size()));
-
-    auto resource_array = json::array();
-    {
-      std::scoped_lock lk(resource_states_alliance_mtx);
-
-      for (const auto& resource : response.resources()) {
-        if (const auto& it = resource_states_alliance.find(resource.id()); it == resource_states_alliance.end() || it->second != resource.amount()) {
-          resource_states_alliance[resource.id()] = resource.amount();
-          resource_array.push_back({{"type", "alliance_" + SyncConfig::Type::Resources}, {"rid", resource.id()}, {"amount", resource.amount()}});
-        }
-      }
-    }
-
-    if (!resource_array.empty()) {
-      workers::queue_data(SyncConfig::Type::Resources, resource_array);
-    }
-  } else {
-    spdlog::error("Failed to parse alliance resources delta");
-  }
-}
-
-static void single_slot_locked(const Digit::PrimeServer::Models::EntitySlot& slot, nlohmann::json& slot_array)
-{
-  using json = nlohmann::json;
-
-  json    slot_params;
-  int64_t state_value = slot.has_slotitemid() ? slot.slotitemid().value() : -1;
-
-  switch (slot.slottype()) {
-    case Digit::PrimeServer::Models::SLOTTYPE_CONSUMABLE:
-      if (slot.has_consumableslotparams()) {
-        const auto& consumable = slot.consumableslotparams();
-        slot_params["expiry_time"] =
-            consumable.has_expirytime() ? json(consumable.expirytime().seconds()) : json(nullptr);
-      }
-      break;
-    case Digit::PrimeServer::Models::SLOTTYPE_OFFICERPRESET:
-      if (slot.has_officerpresetslotparams()) {
-        const auto& preset = slot.officerpresetslotparams();
-        slot_params        = {{"name", preset.name()}, {"order", preset.order()}, {"officer_ids", preset.officerids()}};
-        state_value        = static_cast<int64_t>(std::hash<json>{}(slot_params));
-      }
-      break;
-    case Digit::PrimeServer::Models::SLOTTYPE_FLEETCOMMANDER:
-      if (slot.has_fleetcommanderslotparams()) {
-        slot_params["order"] = slot.fleetcommanderslotparams().order();
-      }
-      break;
-    case Digit::PrimeServer::Models::SLOTTYPE_SELECTABLESKILL:
-      if (slot.has_selectableskillslotparams()) {
-        const auto& skill = slot.selectableskillslotparams();
-        slot_params["cooldown_expiration"] =
-            skill.has_cooldownexpiration() ? json(skill.cooldownexpiration().seconds()) : json(nullptr);
-      }
-      break;
-    case Digit::PrimeServer::Models::SLOTTYPE_FORBIDDENTECH:
-      if (slot.has_forbiddentechslotparams()) {
-        const auto& tech = slot.forbiddentechslotparams();
-        slot_params      = {{"owner_id", tech.ownerid()}, {"tier", tech.tier()}, {"level", tech.level()}};
-        state_value      = static_cast<int64_t>(std::hash<json>{}(slot_params));
-      }
-      break;
-    case Digit::PrimeServer::Models::SLOTTYPE_FLEETPRESET:
-      if (slot.has_fleetpresetslotparams()) {
-        const auto& preset     = slot.fleetpresetslotparams();
-        auto        setup_json = json::array();
-
-        for (const auto& setup : preset.setups()) {
-          setup_json.push_back({{"drydock_id", setup.drydockid()},
-                                {"ship_id", setup.shipids()[0]},
-                                {"officer_ids", setup.officerids()}});
-        }
-
-        slot_params = {{"name", preset.name()}, {"order", preset.order()}, {"setup", setup_json}};
-        state_value = static_cast<int64_t>(std::hash<json>{}(slot_params));
-      }
-      break;
-    default:
-      return;
-  }
-
-  // Lock is not held because caller already does
-  using trackers::slot_states;
-
-  if (const auto& it = slot_states.find(slot.id()); it == slot_states.end() || it->second != state_value) {
-    slot_states[slot.id()] = state_value;
-    slot_array.push_back({{"type", SyncConfig::Type::Slots},
-                          {"sid", slot.id()},
-                          {"slot_type", slot.slottype()},
-                          {"spec_id", slot.slotspecid()},
-                          {"item_id", slot.has_slotitemid() ? json(slot.slotitemid().value()) : json(nullptr)},
-                          {"params", slot_params}});
-  }
-}
-
-static void entity_slots(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-
-  if (auto response = Digit::PrimeServer::Models::EntitySlots(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "entity slots", STR_FORMAT("Processing {} slots", response.entityslots__size()));
-
-    auto slot_array = json::array();
-    {
-      std::scoped_lock lk(trackers::slot_states_mtx);
-
-      for (const auto& slot : response.entityslots_()) {
-        single_slot_locked(slot, slot_array);
-      }
-    }
-
-    if (!slot_array.empty()) {
-      workers::queue_data(SyncConfig::Type::Slots, slot_array);
-    }
-  } else {
-    spdlog::error("Failed to parse entity slots");
-  }
-}
-
-static void entity_slots_data(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-
-  if (auto response = Digit::PrimeServer::Models::EntitySlotsData(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "entity slots data",
-                         STR_FORMAT("Processing {} slots", response.entityslots_size()));
-
-    auto slot_array = json::array();
-    {
-      std::scoped_lock lk(trackers::slot_states_mtx);
-
-      for (const auto& slots : response.entityslots()) {
-        http::logging::trace("PROCESS", "entity slots data",
-                             STR_FORMAT("Processing {} slots for entity {}", slots.slots_size(),
-                                        static_cast<int32_t>(slots.entitytype())));
-
-        for (const auto& slot : slots.slots()) {
-          single_slot_locked(slot, slot_array);
-        }
-      }
-    }
-
-    if (!slot_array.empty()) {
-      workers::queue_data(SyncConfig::Type::Slots, slot_array);
-    }
-  } else {
-    spdlog::error("Failed to parse entity slots data");
-  }
-}
-
-static void forbidden_tech(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  using trackers::types::RankLevelShardsState;
-
-  static std::unordered_map<uint64_t, RankLevelShardsState> tech_states;
-  static std::mutex                                         tech_states_mtx;
-
-  if (auto response = Digit::PrimeServer::Models::ForbiddenTechsResponse(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "techs",
-                         STR_FORMAT("Processing {} forbidden/chaos techs", response.forbiddentechs_size()));
-
-    auto tech_array = json::array();
-    {
-      std::scoped_lock lk(tech_states_mtx);
-
-      for (const auto& tech : response.forbiddentechs()) {
-        const RankLevelShardsState tech_state{tech.tier(), tech.level(), tech.shardcount()};
-
-        if (const auto& it = tech_states.find(tech.id()); it == tech_states.end() || it->second != tech_state) {
-          tech_states[tech.id()] = tech_state;
-          tech_array.push_back({{"type", SyncConfig::Type::Tech},
-                                {"fid", tech.id()},
-                                {"tier", tech.tier()},
-                                {"level", tech.level()},
-                                {"shard_count", tech.shardcount()}});
-        }
-      }
-    }
-
-    if (!tech_array.empty()) {
-      workers::queue_data(SyncConfig::Type::Tech, tech_array);
-    }
-  } else {
-    spdlog::error("Failed to parse forbidden techs");
-  }
-}
-
-static void active_officer_traits(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  using trackers::types::pairhash;
-
-  static std::unordered_map<std::pair<int64_t, int64_t>, int32_t, pairhash> trait_states;
-  static std::mutex                                                         trait_states_mtx;
-
-  if (auto response = Digit::PrimeServer::Models::OfficerTraitsResponse(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "active officer traits",
-                         STR_FORMAT("Processing {} active officer traits", response.activeofficertraits_size()));
-
-    auto trait_array = json::array();
-    {
-      std::scoped_lock lk(trait_states_mtx);
-
-      for (const auto& [officer_id, officer_traits] : response.activeofficertraits()) {
-        for (const auto& trait : officer_traits.activetraits() | std::views::values) {
-          const auto& key = std::make_pair(officer_id, trait.traitid());
-
-          if (const auto& it = trait_states.find(key); it == trait_states.end() || it->second != trait.level()) {
-            trait_states[key] = trait.level();
-            trait_array.push_back({{"type", SyncConfig::Type::Traits},
-                                   {"oid", officer_id},
-                                   {"tid", trait.traitid()},
-                                   {"level", trait.level()}});
-          }
-        }
-      }
-    }
-
-    if (!trait_array.empty()) {
-      workers::queue_data(SyncConfig::Type::Traits, trait_array);
-    }
-  } else {
-    spdlog::error("Failed to parse active officer traits");
-  }
-}
-
-// Store offers arrive in Platform responses. Prices are in Resource.amount; amountUlong is the fallback.
-static int64_t store_offer_amount(const Digit::PrimePlatform::Content::Resource& resource)
-{ return static_cast<int64_t>(resource.amount() != 0 ? resource.amount() : resource.amountulong()); }
-
-// Platform ids are strings; emit numeric ids as numbers like the rest of the sync data.
-static nlohmann::json store_offer_id(const std::string& id)
-{
-  int64_t     value = 0;
-  const auto* end   = id.data() + id.size();
-  if (const auto [ptr, ec] = std::from_chars(id.data(), end, value); !id.empty() && ec == std::errc{} && ptr == end) {
-    return value;
-  }
-
-  return id;
-}
-
-static const Digit::PrimePlatform::Content::ContentItem*
-store_offer_consumable(const Digit::PrimePlatform::Content::BundleContent& content)
-{
-  for (const auto* list : {&content.static_(), &content.showcase(), &content.gifts()}) {
-    for (const auto& item : list->items()) {
-      if (item.type() == "consumable") {
-        return &item;
-      }
-    }
-  }
-
-  return nullptr;
-}
-
-// Emits one snapshot of the faction store's consumable offers (favor levels) whenever its content changes.
-static void store_offers(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-
-  static constexpr std::string_view category           = "factions";
-  static size_t                     store_offers_state = 0;
-  static std::mutex                 store_offers_mtx;
-
-  if (auto response = Digit::PrimePlatform::Content::Bundles(); response.ParseFromString(*bytes)) {
-
-    http::logging::trace("PROCESS", "store offers", STR_FORMAT("Processing {} store offers", response.bundles__size()));
-
-    // A store offers group carries whole categories; skip groups without the faction store.
-    struct Offer {
-      const Digit::PrimePlatform::Content::Bundle*      bundle;
-      const Digit::PrimePlatform::Content::ContentItem* consumable;
-    };
-    std::vector<Offer> bundles;
-    bool               has_category = false;
-    for (const auto& bundle : response.bundles_()) {
-      if (bundle.category() == category) {
-        has_category = true;
-        if (const auto* consumable = store_offer_consumable(bundle.content()); consumable != nullptr) {
-          bundles.push_back({&bundle, consumable});
-        }
-      }
-    }
-    if (!has_category) {
-      return;
-    }
-
-    // Sort by bundle id, then consumable id, so the snapshot (and therefore the de-dup hash) does not depend on server
-    // order.
-    std::ranges::sort(bundles, [](const Offer& a, const Offer& b) {
-      return std::pair{a.bundle->bundleid(), std::string_view{a.consumable->id()}}
-             < std::pair{b.bundle->bundleid(), std::string_view{b.consumable->id()}};
-    });
-
-    auto offers = json::array();
-    for (const auto& [bundle, consumable] : bundles) {
-      auto cost = json::array();
-      for (const auto& entry : bundle->cost()) {
-        for (const auto& resource : entry.cost_()) {
-          cost.push_back({{"rid", store_offer_id(resource.id())}, {"amount", store_offer_amount(resource)}});
-        }
-      }
-
-      // For faction_standing requirements the amount is a zero-based tier index.
-      auto req = json::array();
-      for (const auto& resource : bundle->requirements()) {
-        req.push_back({{"type", resource.type()},
-                       {"id", store_offer_id(resource.id())},
-                       {"amount", store_offer_amount(resource)}});
-      }
-
-      const auto& details = bundle->offerdetails();
-      offers.push_back({{"bid", bundle->bundleid()},
-                        {"cid", store_offer_id(consumable->id())},
-                        {"cost", cost},
-                        {"req", req},
-                        {"valid_count", details.validcount()},
-                        {"same_remaining_count", details.sameremainingcount()}});
-    }
-
-    json event = {{"type", SyncConfig::Type::StoreOffers}, {"category", category}, {"offers", offers}};
-
-    // Queue under the lock so the remembered snapshot and the queue order agree.
-    const auto       state_value = std::hash<json>{}(event);
-    std::scoped_lock lk(store_offers_mtx);
-    if (store_offers_state != state_value) {
-      store_offers_state = state_value;
-      workers::queue_data(SyncConfig::Type::StoreOffers, json::array({event}));
-    }
-  } else {
-    spdlog::error("Failed to parse store offers");
-  }
-}
-
-namespace deployed_fleets
-{
-  using Digit::PrimeServer::Models::ClientModifierType;
-  using Digit::PrimeServer::Models::DeployedFleetState;
-
-  static const char* state_name(DeployedFleetState state)
-  {
-    switch (state) {
-      case Digit::PrimeServer::Models::DEPLOYEDFLEETSTATE_IDLE:
-        return "Idle";
-      case Digit::PrimeServer::Models::DEPLOYEDFLEETSTATE_MOVING:
-        return "Moving";
-      case Digit::PrimeServer::Models::DEPLOYEDFLEETSTATE_WARPING:
-        return "Warping";
-      case Digit::PrimeServer::Models::DEPLOYEDFLEETSTATE_BATTLING:
-        return "Battling";
-      case Digit::PrimeServer::Models::DEPLOYEDFLEETSTATE_RECALL:
-        return "Recall";
-      // docked at a mining node, not the station
-      case Digit::PrimeServer::Models::DEPLOYEDFLEETSTATE_DOCKED:
-        return "OnNode";
-      case Digit::PrimeServer::Models::DEPLOYEDFLEETSTATE_PREBATTLE:
-        return "PreBattle";
-      default:
-        return "Unknown";
-    }
-  }
-
-  // 1234 not 1234.0, and 14.364 not 14.36400032043457
-  static nlohmann::json number(float value)
-  {
-    if (std::trunc(value) == value && std::abs(value) < 9.0e15f) {
-      return static_cast<int64_t>(value);
-    }
-
-    char   buffer[32];
-    double widened = value;
-    if (const auto [end, ec] = std::to_chars(std::begin(buffer), std::end(buffer), value); ec == std::errc{}) {
-      // Floating-point from_chars requires macOS 26; use the existing JSON parser on supported clients.
-      auto parsed = nlohmann::json::parse(std::begin(buffer), end, nullptr, false);
-      if (parsed.is_number()) {
-        return parsed;
-      }
-    }
-    return widened;
-  }
-
-  using FloatMap = google::protobuf::Map<int32_t, float>;
-
-  static std::optional<float> lookup(const FloatMap& map, ClientModifierType key)
-  {
-    if (const auto it = map.find(key); it != map.end()) {
-      return it->second;
-    }
-    return std::nullopt;
-  }
-
-  // leave missing stats out instead of sending 0
-  static void put(nlohmann::json& record, const char* name, const FloatMap& map, ClientModifierType key)
-  {
-    if (const auto value = lookup(map, key); value && std::isfinite(*value)) {
-      record[name] = number(*value);
-    }
-  }
-
-  // summed over the fleet's ships: shipStats has the max, shipAttributes the damage taken
-  static void put_points(nlohmann::json& record, const char* current_name, const char* max_name,
-                         const Digit::PrimeServer::Models::DeployedFleet& fleet, ClientModifierType max_key,
-                         ClientModifierType damage_key)
-  {
-    double total_max    = 0;
-    double total_damage = 0;
-    bool   found        = false;
-
-    for (const auto& [ship_id, stats] : fleet.shipstats()) {
-      const auto max = lookup(stats.shipattributes_(), max_key);
-      if (!max) {
-        continue;
-      }
-
-      found = true;
-      total_max += *max;
-      if (const auto it = fleet.shipattributes().find(ship_id); it != fleet.shipattributes().end()) {
-        total_damage += lookup(it->second.shipattributes_(), damage_key).value_or(0.0f);
-      }
-    }
-
-    if (found) {
-      record[current_name] = std::llround(std::max(0.0, total_max - total_damage));
-      record[max_name]     = std::llround(total_max);
-    }
-  }
-} // namespace deployed_fleets
-
-static void my_deployed_fleets(std::unique_ptr<std::string>&& bytes)
-{
-  using json = nlohmann::json;
-  using namespace Digit::PrimeServer::Models;
-  using deployed_fleets::put;
-
-  auto response = MyDeployedFleetsResponse();
-  if (!response.ParseFromString(*bytes)) {
-    spdlog::error("Failed to parse deployed fleets");
-    return;
-  }
-
-  http::logging::trace("PROCESS", "deployed fleets", STR_FORMAT("Processing {} fleets", response.fleets_size()));
-
-  // the server resends every fleet on each update, so only send the ones that changed
-  static std::unordered_map<int64_t, size_t> last_sent;
-  static std::mutex                          last_sent_mtx;
-
-  const int64_t now =
-      std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
-  auto fleet_array = json::array();
-
-  for (const auto& [fleet_id, fleet] : response.fleets()) {
-    json record = {{"type", SyncConfig::Type::Fleets},
-                   {"fid", fleet_id},
-                   {"src", "server"},
-                   {"server_state", static_cast<int>(fleet.state())},
-                   {"server_state_name", deployed_fleets::state_name(fleet.state())},
-                   {"node_id", fleet.nodeid()}};
-
-    if (fleet.hullids_size() > 0) {
-      // widen through uint32 like the client records
-      record["hull_id"] = static_cast<int64_t>(static_cast<uint32_t>(fleet.hullids(0)));
-    }
-
-    if (fleet.has_nodeaddress()) {
-      record["system_id"] = fleet.nodeaddress().system();
-    }
-
-    deployed_fleets::put_points(record, "hull_hp", "hull_max", fleet, CLIENTMODIFIERTYPE_MODHULLHPMAX,
-                                CLIENTMODIFIERTYPE_SHIPHULLDAMAGE);
-    deployed_fleets::put_points(record, "shield_hp", "shield_max", fleet, CLIENTMODIFIERTYPE_MODSHIELDHPMAX,
-                                CLIENTMODIFIERTYPE_SHIPSHIELDDAMAGE);
-
-    const auto& stats = fleet.stats();
-    put(record, "cargo_cap", stats, CLIENTMODIFIERTYPE_MODCARGOCAPACITY);
-    put(record, "warp_range", stats, CLIENTMODIFIERTYPE_MODWARPDISTANCE);
-    put(record, "strength", fleet.attributes(), CLIENTMODIFIERTYPE_FLEETSTRENGTH);
-
-    // a count only, no other players' ids
-    record["pursued_by"] = fleet.pursuedbynum();
-
-    const auto       state_value = std::hash<json>{}(record);
-    std::scoped_lock lk(last_sent_mtx);
-    if (auto& last = last_sent[fleet_id]; last != state_value) {
-      last = state_value;
-      record["t"] = now;
-      fleet_array.push_back(std::move(record));
-      fleets::request_reread(fleet_id);
-    }
-  }
-
-  // forget fleets that left (docked, destroyed), so they're sent again when they're back
-  {
-    std::scoped_lock lk(last_sent_mtx);
-    std::erase_if(last_sent, [&](const auto& entry) {
-      if (response.fleets().contains(entry.first)) {
-        return false;
-      }
-      fleets::request_reread(entry.first);
-      return true;
-    });
-  }
-
-  if (!fleet_array.empty()) {
-    workers::queue_data(SyncConfig::Type::Fleets, fleet_array, /*is_first_sync=*/false);
-  }
-}
-
-namespace json
-{
-  static void battle_result_headers(const nlohmann::json& section)
-  {
-    http::logging::trace("PROCESS", "battle headers", STR_FORMAT("Processing {} battle headers", section.size()));
-
-    std::vector<uint64_t> battle_ids;
-    battle_ids.reserve(section.size());
-
-    for (const auto& battle : section) {
-      const auto id = battle["id"].get<uint64_t>();
-      battle_ids.push_back(id);
-    }
-
-    queue_battle_ids(battle_ids);
-  }
-
-  static void resources(const nlohmann::json& section)
-  {
-    using json = nlohmann::json;
-    using trackers::resource_states;
-    using trackers::resource_states_mtx;
-    static std::atomic_bool is_first_sync{true};
-
-    http::logging::trace("PROCESS", "resources", STR_FORMAT("Processing {} resources (JSON)", section.size()));
-
-    auto resource_array = json::array();
-    {
-      std::scoped_lock lk(resource_states_mtx);
-
-      for (const auto& [str_id, resource] : section.get<json::object_t>()) {
-        auto id     = std::stoll(str_id);
-        auto amount = resource["current_amount"].get<int64_t>();
-
-        if (const auto& it = resource_states.find(id); it == resource_states.end() || it->second != amount) {
-          resource_states[id] = amount;
-          resource_array.push_back({{"type", SyncConfig::Type::Resources}, {"rid", id}, {"amount", amount}});
-        }
-      }
-    }
-
-    if (!resource_array.empty()) {
-      const bool first_sync = is_first_sync.exchange(false, std::memory_order_acq_rel);
-      workers::queue_data(SyncConfig::Type::Resources, resource_array, first_sync);
-    }
-  }
-
-  static void starbase_modules(const nlohmann::json& section)
-  {
-    using json = nlohmann::json;
-    using trackers::module_states;
-    using trackers::module_states_mtx;
-
-    http::logging::trace("PROCESS", "starbase modules", STR_FORMAT("Processing {} buildings (JSON)", section.size()));
-
-    auto starbase_array = json::array();
-    {
-      std::scoped_lock lk(module_states_mtx);
-
-      for (const auto& module : section.get<json::object_t>() | std::views::values) {
-        const auto id    = module["id"].get<int64_t>();
-        const auto level = module["level"].get<int32_t>();
-
-        if (const auto& it = module_states.find(id); it == module_states.end() || it->second != level) {
-          module_states[id] = level;
-          starbase_array.push_back({{"type", SyncConfig::Type::Buildings}, {"bid", id}, {"level", level}});
-        }
-      }
-    }
-
-    if (!starbase_array.empty()) {
-      workers::queue_data(SyncConfig::Type::Buildings, starbase_array);
-    }
-  }
-
-  static void ships(const nlohmann::json& section)
-  {
-    using json = nlohmann::json;
-
-    http::logging::trace("PROCESS", "ships", STR_FORMAT("Processing {} ships (JSON)", section.size()));
-
-    std::vector<ShipRecord> records;
-    records.reserve(section.size());
-
-    for (const auto& ship : section.get<json::object_t>() | std::views::values) {
-      records.push_back({ship["id"].get<int64_t>(), ship["hull_id"].get<int64_t>(), ship["tier"].get<int32_t>(),
-                         ship["level"].get<int32_t>(), ship["level_percentage"].get<double_t>(),
-                         ship["components"].get<std::vector<int64_t>>()});
-    }
-
-    sync_ships(records);
-  }
-
-  static void parse(std::unique_ptr<std::string>&& bytes)
-  {
-    using json = nlohmann::json;
-    const auto& sync_options = Config::Get().sync_options;
-
-    try {
-      const auto result = json::parse(bytes->begin(), bytes->end());
-
-      for (const auto& [key, section] : result.items()) {
-        if (key == "battle_result_headers") {
-          if (!sync_options.battlelogs) {
-            continue;
-          }
-
-          battle_result_headers(section);
-
-        } else if (key == "resources") {
-          if (!sync_options.resources) {
-            continue;
-          }
-
-          resources(section);
-
-        } else if (key == "starbase_modules") {
-          if (!sync_options.buildings) {
-            continue;
-          }
-
-          starbase_modules(section);
-
-        } else if (key == "ships") {
-          if (!sync_options.ships) {
-            continue;
-          }
-
-          ships(section);
-        }
-      }
-    } catch (const json::exception& e) {
-      spdlog::error("Error parsing json: {}", e.what());
-    }
-  }
-} // namespace json
-
-namespace rtc
-{
-  static void entity_slots(std::unique_ptr<std::string>&& json_payload)
-  {
-    using json = nlohmann::json;
-
-    try {
-      auto data = json::parse(*json_payload);
-      http::logging::trace("PROCESS", "entity slots (RTC)", "Processing entity slot update");
-
-      const auto item    = data["slot_item_id"];
-      const auto item_id = item.is_null() ? -1 : item.get<int64_t>();
-
-      json    slot_params;
-      int64_t state_value = item_id;
-
-      const auto type = data["slot_type"].get<int32_t>();
-      switch (type) {
-        case Digit::PrimeServer::Models::SLOTTYPE_CONSUMABLE:
-          if (const auto& expiry_time = data["consumable_slot_params"]["expiry_time"]; expiry_time.is_null()) {
-            slot_params["expiry_time"] = nullptr;
-          } else {
-            const auto timestamp =
-                parse_timestamp(data["consumable_slot_params"]["expiry_time"].get_ref<const std::string&>());
-            if (timestamp.has_value()) {
-              slot_params["expiry_time"] = timestamp.value().time_since_epoch().count();
-            } else {
-              slot_params["expiry_time"] = nullptr;
-            }
-          }
-          break;
-        case Digit::PrimeServer::Models::SLOTTYPE_OFFICERPRESET:
-          if (const auto& preset = data["officer_preset_slot_params"]; !preset.is_null()) {
-            slot_params = preset;
-            state_value = static_cast<int64_t>(std::hash<json>{}(slot_params));
-          }
-          break;
-        case Digit::PrimeServer::Models::SLOTTYPE_FLEETCOMMANDER:
-          if (const auto& params = data["fleet_commander_slot_params"]; !params.is_null()) {
-            slot_params["order"] = params["order"];
-          }
-          break;
-        case Digit::PrimeServer::Models::SLOTTYPE_SELECTABLESKILL:
-          if (const auto& params = data["selectable_skill_slot_params"]; !params.is_null()) {
-            if (const auto& expiry_time = params["cooldown_expiration"]; expiry_time.is_null()) {
-              slot_params["cooldown_expiration"] = nullptr;
-            } else {
-              const auto timestamp = parse_timestamp(params["cooldown_expiration"].get_ref<const std::string&>());
-              if (timestamp.has_value()) {
-                slot_params["cooldown_expiration"] = timestamp.value().time_since_epoch().count();
-              } else {
-                slot_params["cooldown_expiration"] = nullptr;
-              }
-            }
-          }
-          break;
-        case Digit::PrimeServer::Models::SLOTTYPE_FORBIDDENTECH:
-          if (const auto& tech = data["forbidden_tech_slot_params"]; !tech.is_null()) {
-            slot_params = tech;
-            state_value = static_cast<int64_t>(std::hash<json>{}(slot_params));
-          }
-          break;
-        case Digit::PrimeServer::Models::SLOTTYPE_FLEETPRESET:
-          if (const auto& params = data["fleet_preset_slot_params"]; !params.is_null()) {
-            auto setup_json = json::array();
-            for (const auto& setup : params["setups"]) {
-              setup_json.push_back(
-                  {{"drydock_id", setup["d"]}, {"ship_id", setup["s"][0]}, {"officer_ids", setup["o"]}});
-            }
-
-            slot_params = {{"name", params["name"]}, {"order", params["order"]}, {"setup", setup_json}};
-            state_value = static_cast<int64_t>(std::hash<json>{}(slot_params));
-          }
-          break;
-        default:
-          return;
-      }
-
-      const auto id = data["slot_id"].get<int64_t>();
-      {
-        using trackers::slot_states;
-        using trackers::slot_states_mtx;
-
-        std::scoped_lock lk(slot_states_mtx);
-
-        if (const auto& it = slot_states.find(id); it == slot_states.end() || it->second != state_value) {
-          slot_states[id] = state_value;
-
-          auto slot_array = json::array();
-          slot_array.push_back({{"type", SyncConfig::Type::Slots},
-                                {"sid", id},
-                                {"slot_type", type},
-                                {"spec_id", data["slot_spec_id"]},
-                                {"item_id", item},
-                                {"params", slot_params}});
-
-          workers::queue_data(SyncConfig::Type::Slots, slot_array);
-        }
-      }
-    } catch (json::exception& e) {
-      spdlog::error("Failed to parse slots JSON: {}", e.what());
-    }
-  }
-} // namespace rtc
-
-} // namespace processors
-
-static void HandleEntityGroup(EntityGroup* entity_group)
-{
-  if (entity_group == nullptr) {
-    return;
-  }
-  auto* const group = entity_group->Group();
-  if (group == nullptr || group->bytes() == nullptr || group->Length() <= 0) {
-    return;
-  }
-
-  const auto byteCount = static_cast<size_t>(group->Length());
-  const auto *bytesPtr = reinterpret_cast<const char*>(group->bytes()->data());
-
-  // Helper to run processing asynchronously with exception handling
-  auto submit_async = [bytesPtr, byteCount]<typename T>(T&& func) {
-    auto payload = std::make_unique<std::string>(bytesPtr, byteCount);
-
-    try {
-      std::thread([f = std::forward<T>(func), p = std::move(payload)]() mutable {
-        try {
-          f(std::move(p));
-        } catch (const std::exception& e) {
-          spdlog::error("Exception in HandleEntityGroup: {}", e.what());
-        } catch (...) {
-          spdlog::error("Unknown exception in HandleEntityGroup");
-        }
-      }).detach();
-    } catch (const std::exception& e) {
-      spdlog::error("Failed to spawn async task: {}", e.what());
-    } catch (...) {
-      spdlog::error("Failed to spawn async task: unknown exception");
-    }
-  };
-
-  const auto& sync_options = Config::Get().sync_options;
-
-  switch (entity_group->Type_()) {
-    // away assignments
-    case EntityGroup::Type::AwayAssignmentsList:
-      if (sync_options.away_assignments) {
-        submit_async(processors::away_assignments_list);
-      }
-      break;
-    case EntityGroup::Type::AwayAssignmentsInstance:
-      if (sync_options.away_assignments) {
-        submit_async(processors::away_assignment_instance);
-      }
-      break;
-    // battlelogs
-    case EntityGroup::Type::BattleResultHeaders:
-      if (sync_options.battlelogs) {
-        submit_async(processors::battle_result_headers);
-      }
-      break;
-    case EntityGroup::Type::BattleReport:
-      if (sync_options.battlelogs) {
-        submit_async(processors::battle_report);
-      }
-      break;
-    case EntityGroup::Type::UserProfiles:
-      if (sync_options.battlelogs) {
-        submit_async(trackers::names::cache_player_names);
-      }
-      if (sync_options.profile) {
-        // Skipped if the local profile is not ready; a later response retries.
-        auto* const local = processors::local_user_profile();
-        if (auto self = processors::local_user_id(local); !self.empty()) {
-          submit_async([self = std::move(self), level = local->Level()](std::unique_ptr<std::string>&& bytes) {
-            processors::own_profile(std::move(bytes), self, level);
-          });
-        }
-      }
-      break;
-    case EntityGroup::Type::AllianceProfiles:
-      if (sync_options.battlelogs) {
-        submit_async(trackers::names::cache_alliance_names);
-      }
-      break;
-
-    // buffs
-    case EntityGroup::Type::GlobalActiveBuffs:
-      if (sync_options.buffs) {
-        submit_async(processors::global_active_buffs);
-      }
-      break;
-    case EntityGroup::Type::AllianceGetGameProperties:
-      if (sync_options.buffs) {
-        submit_async(processors::alliance_games_props);
-      }
-      break;
-
-    // buildings
-    case EntityGroup::Type::StarbaseModules:
-      if (sync_options.buildings) {
-        submit_async(processors::starbase_modules);
-      }
-      break;
-
-    // haven
-    case EntityGroup::Type::PlanetaryBaseData:
-      if (sync_options.haven) {
-        submit_async(processors::planetary_base_data);
-      }
-      break;
-
-    case EntityGroup::Type::PlanetaryMapData:
-      if (sync_options.haven) {
-        submit_async(processors::planetary_map_data);
-      }
-      break;
-
-    case EntityGroup::Type::PlanetaryMapProsperity:
-      if (sync_options.haven) {
-        submit_async(processors::planetary_map_prosperity);
-      }
-      break;
-
-    case EntityGroup::Type::PlanetaryMapResponse:
-      if (sync_options.haven) {
-        submit_async(processors::planetary_map);
-      }
-      break;
-
-    // inventory
-    case EntityGroup::Type::PlayerInventories:
-      if (sync_options.inventory) {
-        submit_async(processors::player_inventories);
-      }
-      break;
-
-    // jobs
-    case EntityGroup::Type::Jobs:
-      if (sync_options.jobs) {
-        submit_async(processors::jobs);
-      }
-      break;
-
-    // missions
-    case EntityGroup::Type::ActiveMissions:
-      if (sync_options.missions) {
-        submit_async(processors::active_missions);
-      }
-      break;
-    case EntityGroup::Type::CompletedMissions:
-      if (sync_options.missions) {
-        submit_async(processors::completed_missions);
-      }
-      break;
-
-    // officer
-    case EntityGroup::Type::Officers:
-      if (sync_options.officers) {
-        submit_async(processors::officers);
-      }
-      break;
-
-    // research
-    case EntityGroup::Type::ResearchTreesState:
-      if (sync_options.research) {
-        submit_async(processors::research_trees_state);
-      }
-      break;
-
-    // resources
-    case EntityGroup::Type::Resources:
-      if (sync_options.resources) {
-        submit_async(processors::resources);
-      }
-      break;
-    case EntityGroup::Type::ResourcesDelta:
-      if (sync_options.resources) {
-        submit_async(processors::resources_delta);
-      }
-      break;
-    case EntityGroup::Type::AllianceGetBankResources:
-      if (sync_options.resources) {
-        submit_async(processors::alliance_resources);
-      }
-      break;
-    case EntityGroup::Type::ResourcesDeltaAlliance:
-      if (sync_options.resources) {
-        submit_async(processors::alliance_resources_delta);
-      }
-      break;
-
-    // ships
-    case EntityGroup::Type::Ships:
-      if (sync_options.ships) {
-        submit_async(processors::player_ships);
-      }
-      break;
-
-    // slots
-    case EntityGroup::Type::EntitySlots:
-      if (sync_options.slots) {
-        submit_async(processors::entity_slots);
-      }
-      break;
-    case EntityGroup::Type::EntitySlotsData:
-      if (sync_options.slots) {
-        submit_async(processors::entity_slots_data);
-      }
-      break;
-
-    // tech
-    case EntityGroup::Type::ForbiddenTechs:
-    if (sync_options.tech) {
-      submit_async(processors::forbidden_tech);
-    }
-    break;
-
-    // traits
-    case EntityGroup::Type::ActiveOfficerTraits:
-      if (sync_options.traits) {
-        submit_async(processors::active_officer_traits);
-      }
-      break;
-
-    // fleets
-    case EntityGroup::Type::MyDeployedFleets:
-      if (sync_options.fleets) {
-        submit_async(processors::my_deployed_fleets);
-      }
-      break;
-
-    // misc
-    case EntityGroup::Type::Json:
-      submit_async(processors::json::parse);
-      break;
-
-    default:
-      break;
-  }
-}
-
-// Platform responses (store offers among them) reach the same ProcessResultInternal detour as game server responses:
-// both model registries share one compiled method. Their entity groups use the Platform type enum, so they must not
-// go through HandleEntityGroup.
-static void HandlePlatformResponse(PlatformServiceResponse* response)
-{
-  auto* const entity_groups = response->EntityGroups();
-  if (entity_groups == nullptr) {
-    return;
-  }
-
-  for (auto* const entity_group : *entity_groups) {
-    if (entity_group == nullptr || entity_group->Type_() != PlatformEntityGroup::StoreOffers) {
-      continue;
-    }
-    auto* const group = entity_group->Group();
-    if (group == nullptr || group->bytes() == nullptr || group->Length() <= 0) {
-      continue;
-    }
-
-    auto payload = std::make_unique<std::string>(reinterpret_cast<const char*>(group->bytes()->data()),
-                                                 static_cast<size_t>(group->Length()));
-    try {
-      std::thread([p = std::move(payload)]() mutable {
-        try {
-          processors::store_offers(std::move(p));
-        } catch (const std::exception& e) {
-          spdlog::error("Exception in HandlePlatformResponse: {}", e.what());
-        } catch (...) {
-          spdlog::error("Unknown exception in HandlePlatformResponse");
-        }
-      }).detach();
-    } catch (const std::exception& e) {
-      spdlog::error("Failed to spawn async task: {}", e.what());
-    } catch (...) {
-      spdlog::error("Failed to spawn async task: unknown exception");
-    }
-  }
-}
-
-namespace fleets
-{
-constexpr int kFleetSlotCount = 10;
-
-static const char* state_name(FleetState state)
-{
-  switch (state) {
-    case FleetState::IdleInSpace:
-      return "IdleInSpace";
-    case FleetState::Docked:
-      return "Docked";
-    case FleetState::Mining:
-      return "Mining";
-    case FleetState::Destroyed:
-      return "Destroyed";
-    case FleetState::TieringUp:
-      return "TieringUp";
-    case FleetState::Repairing:
-      return "Repairing";
-    case FleetState::Battling:
-      return "Battling";
-    case FleetState::WarpCharging:
-      return "WarpCharging";
-    case FleetState::Warping:
-      return "Warping";
-    case FleetState::Impulsing:
-      return "Impulsing";
-    case FleetState::Capturing:
-      return "Capturing";
-    case FleetState::AutoHunting:
-      return "AutoHunting";
-    case FleetState::Outposting:
-      return "Outposting";
-    default:
-      return "Unknown";
-  }
-}
-
-static int64_t unix_seconds()
-{
-  return std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
-}
-
-template <typename T> static void put(nlohmann::json& out, const char* key, const std::optional<T>& value)
-{
-  if (value) {
-    out[key] = *value;
-  }
-}
-
-// Game thread only. Absent objects and unset times are left out; members missing from the client read as zero.
-static void add_live_state(nlohmann::json& out, FleetPlayerData* fleet, FleetState state)
-{
-  const auto is_mining    = fleet->IsMining();
-  const auto is_repairing = fleet->IsRepairing();
-
-  const auto is_home      = fleet->IsHome();
-  const auto is_destroyed = fleet->IsDestroyed();
-
-  out["is_home"]      = is_home;
-  out["is_deployed"]  = fleet->IsDeployed();
-  out["is_mining"]    = is_mining;
-  out["is_repairing"] = is_repairing;
-  out["is_damaged"]   = fleet->IsDamaged();
-  out["is_destroyed"] = is_destroyed;
-  out["drydock"]      = fleet->DrydockID();
-  // the client only updates this at the station; in space the server's hull points are the live value
-  if (is_home || is_destroyed) {
-    if (const auto damage = fleet->HullDamage()) {
-      out["hull_damage"] = std::llround(*damage);
-    }
-  }
-  out["cargo_fill"] = fleet->CargoResourceFillLevel();
-
-  if (auto* hold = fleet->CargoHold()) {
-    if (auto* current = hold->CurrentCargo()) {
-      out["cargo"]     = current->CurrentValue();
-      out["cargo_max"] = current->MaxValue();
-    }
-    if (auto* protected_cargo = hold->ProtectedCargoProgress()) {
-      out["protected_cargo"] = protected_cargo->CurrentValue();
-    }
-  }
-
-  if (is_mining) {
-    if (auto* slot = fleet->MiningData()) {
-      out["node_id"]       = slot->ParentId();
-      out["node_resource"] = slot->ResourceId();
-      out["amount_mined"]  = slot->AmountMined();
-      put(out, "occupied_since", slot->OccupyTimeUtc().UnixSeconds());
-      if (auto* node = slot->PointData()) {
-        out["node_amount"] = node->Amount();
-      }
-    }
-    out["mining_rate"] = fleet->GetMiningRate();
-
-    if (auto* timer = fleet->MiningSlotTimer()) {
-      put(out, "mining_due", timer->DueTime().UnixSeconds());
-    }
-  }
-
-  if (is_repairing) {
-    if (auto* timer = fleet->Timer()) {
-      put(out, "repair_due", timer->DueTime().UnixSeconds());
-    }
-  }
-
-  if (state == FleetState::WarpCharging || state == FleetState::Warping || state == FleetState::Impulsing) {
-    if (auto* timer = fleet->Timer()) {
-      put(out, "travel_due", timer->DueTime().UnixSeconds());
-    }
-  }
-}
-
-// Game thread only. The values the client fills in late, as last sent per fleet; a re-read is only sent when they
-// changed. Values that move on their own are left out: cargo while mining, hull while repairing.
-static std::unordered_map<uint64_t, size_t> sent_late;
-
-static size_t late_fields(const nlohmann::json& record)
-{
-  auto fields = nlohmann::json::object();
-  for (const auto* key :
-       {"is_damaged", "is_destroyed", "is_repairing", "repair_due", "travel_due", "hull_damage", "mining_due", "node_id",
-        "cargo_max"}) {
-    if (const auto it = record.find(key); it != record.end()) {
-      fields[key] = *it;
-    }
-  }
-  if (record.value("is_repairing", false)) {
-    fields.erase("hull_damage");
-  }
-  return std::hash<nlohmann::json>{}(fields);
-}
-
-// Game thread only: reads IL2CPP properties of a FleetPlayerData that is valid for the current frame.
-static nlohmann::json record(int slot, FleetPlayerData* fleet, FleetState state, FleetState previous)
-{
-  auto*         hull    = fleet->Hull();
-  // Hull ids are 32-bit and run past 2^31 (e.g. Kumari 3005922948); take the value as unsigned before widening so
-  // those never come out negative in the record.
-  const int64_t hull_id = hull ? static_cast<int64_t>(static_cast<uint32_t>(hull->Id())) : 0;
-
-  nlohmann::json out = {{"type", SyncConfig::Type::Fleets},
-                        {"fid", fleet->Id()},
-                        {"slot", slot},
-                        {"hull_id", hull_id},
-                        {"level", fleet->Level()},
-                        {"state", static_cast<int>(state)},
-                        {"state_name", state_name(state)},
-                        {"prev_state", static_cast<int>(previous)},
-                        {"prev_state_name", state_name(previous)},
-                        {"t", unix_seconds()},
-                        {"src", "client"}};
-  try {
-    add_live_state(out, fleet, state);
-  } catch (const std::exception& e) {
-    spdlog::warn("Sync: fleet live state read failed for {}: {}", fleet->Id(), e.what());
-  }
-
-  sent_late[fleet->Id()] = late_fields(out);
-  return out;
-}
-
-// Game thread only. A snapshot is the complete list of occupied slots, so it is sent as a first sync.
-static void queue_snapshot(const char* reason)
-{
-  auto* manager = FleetsManager::Instance();
-  if (!manager || !manager->HasFleetService()) {
-    return;
-  }
-
-  auto fleet_array = nlohmann::json::array();
-  for (int slot = 0; slot < kFleetSlotCount; ++slot) {
-    if (auto* fleet = manager->GetFleetPlayerData(slot); fleet) {
-      fleet_array.push_back(record(slot, fleet, fleet->CurrentState(), fleet->PreviousState()));
-    }
-  }
-
-  if (!fleet_array.empty()) {
-    http::logging::debug("PROCESS", "fleets", STR_FORMAT("Fleet snapshot ({}): {} fleets", reason, fleet_array.size()));
-    workers::queue_data(SyncConfig::Type::Fleets, fleet_array, true);
-  }
-}
-
-static void on_transition(const fleet_watch::Transition& transition)
-{
-  if (!transition.fleet) {
-    return;
-  }
-
-  auto fleet_array = nlohmann::json::array();
-  fleet_array.push_back(
-      record(transition.after.slot, transition.fleet, transition.after.state, transition.before.state));
-  workers::queue_data(SyncConfig::Type::Fleets, fleet_array);
-}
-
-static void on_baseline()
-{
-  snapshot_requested.store(false, std::memory_order_relaxed);
-  queue_snapshot("baseline");
-}
-
-// Game thread only.
-static void reread_requested()
-{
-  std::vector<uint64_t> due;
-  {
-    std::scoped_lock lk(reread_mtx);
-    if (reread_at.empty()) {
-      return;
-    }
-    const auto now = std::chrono::steady_clock::now();
-    std::erase_if(reread_at, [&](const auto& entry) {
-      if (entry.second > now) {
-        return false;
-      }
-      due.push_back(entry.first);
-      return true;
-    });
-  }
-  if (due.empty()) {
-    return;
-  }
-
-  auto* manager = FleetsManager::Instance();
-  if (!manager || !manager->HasFleetService()) {
-    return;
-  }
-
-  auto fleet_array = nlohmann::json::array();
-  for (int slot = 0; slot < kFleetSlotCount; ++slot) {
-    try {
-      auto* fleet = manager->GetFleetPlayerData(slot);
-      if (!fleet || std::ranges::find(due, fleet->Id()) == due.end()) {
-        continue;
-      }
-      const auto before = sent_late[fleet->Id()];
-      auto       entry  = record(slot, fleet, fleet->CurrentState(), fleet->PreviousState());
-      if (late_fields(entry) != before) {
-        fleet_array.push_back(std::move(entry));
-      }
-    } catch (const std::exception& e) {
-      spdlog::warn("Sync: fleet re-read failed for slot {}: {}", slot, e.what());
-    }
-  }
-
-  if (!fleet_array.empty()) {
-    workers::queue_data(SyncConfig::Type::Fleets, fleet_array);
-  }
-}
-
-static void tick()
-{
-  reread_requested();
-
-  if (!snapshot_requested.load(std::memory_order_relaxed)
-      || !snapshot_requested.exchange(false, std::memory_order_acq_rel)) {
-    return;
-  }
-  queue_snapshot("first sync");
-}
-
-static void install()
-{
-  if (!Config::Get().sync_options.fleets) {
-    return;
-  }
-
-  if (!fleet_watch::Subscribe({.on_transition = on_transition, .on_baseline = on_baseline})) {
-    spdlog::warn("Sync: fleet state subscriber could not be installed; fleet sync disabled");
-    return;
-  }
-
-  register_screen_manager_update_callback(tick);
-  spdlog::info("Sync: fleet state sync enabled");
-}
-} // namespace fleets
-
-using GameServerModelRegistry =
-    il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Core", "GameServerModelRegistry">;
-using GameServer = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Core", "GameServer">;
-using SlotAssignRtcParser =
-    il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Parsers", "SlotAssignRtcParser">;
-using SlotClearRtcParser =
-    il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Parsers", "SlotClearRtcParser">;
-
-namespace hooks
-{
-// IL2CPP value type: keep this parameter by value so following arguments retain their platform ABI positions.
-struct CentrifugoInfo {
-  Il2CppString* Channel;
-  int32_t       Offset;
-};
-
-static_assert(sizeof(CentrifugoInfo) == 16);
-
-static void* RtcParser_ParseFinalPayload(auto original, void* _this, CentrifugoInfo centrifugoInfo,
-                                         RealtimeDataPayload* realtimeDataPayload, void* finalPayload)
-{
-  if (realtimeDataPayload != nullptr && realtimeDataPayload->Target() != nullptr
-      && realtimeDataPayload->DataType() != nullptr && realtimeDataPayload->Data() != nullptr) {
-    if (const auto type_string = to_string(realtimeDataPayload->DataType()); std::stoi(type_string) == DataType::JSON) {
-      const auto target   = to_string(realtimeDataPayload->Target());
-      const auto rtc_data = to_string(realtimeDataPayload->Data());
-
-      // spdlog::debug("Received RTC payload for target '{}': {}", target, rtc_data);
-      auto payload = std::make_unique<std::string>(rtc_data);
-
-      std::thread([p = std::move(payload)]() mutable {
-        try {
-          processors::rtc::entity_slots(std::move(p));
-        } catch (const std::exception& e) {
-          spdlog::error("Exception in RtcParser_ParseFinalPayload: {}", e.what());
-        } catch (...) {
-          spdlog::error("Unknown exception in RtcParser_ParseFinalPayload");
-        }
-      }).detach();
-    }
-  }
-
-  return original(_this, centrifugoInfo, realtimeDataPayload, finalPayload);
-}
-
-static void GameServerModelRegistry_ProcessResultInternal(auto original, void* _this, void* parsing_context,
-                                                          ServiceResponse* service_response, MethodInfo* method)
-{
-  // Only the store offers option looks at Platform responses; everyone else keeps the unchanged path below.
-  if (Config::Get().sync_options.store_offers && service_response != nullptr) {
-    if (auto* const platform = service_response->As<PlatformServiceResponse>()) {
-      HandlePlatformResponse(platform);
-      return original(_this, parsing_context, service_response, method);
-    }
-  }
-
-  // The hooked method is shared generic code; PlatformModelRegistry passes its own response type.
-  auto* const entity_groups =
-      service_response && service_response->Is<ServiceResponse>() ? service_response->EntityGroups() : nullptr;
-  if (entity_groups) {
-    for (auto* const entity_group : *entity_groups) {
-      HandleEntityGroup(entity_group);
-    }
-  }
-
-  return original(_this, parsing_context, service_response, method);
-}
-
-static void PrimeApp_InitPrimeServer(auto original, void* _this, Il2CppString* gameServerUrl,
-                                     Il2CppString* gatewayServerUrl, Il2CppString* sessionId,
-                                     Il2CppString* serverRegion)
-{
-  original(_this, gameServerUrl, gatewayServerUrl, sessionId, serverRegion);
-  http::headers::instanceSessionId = to_string(sessionId);
-  http::headers::gameServerUrl     = to_string(gameServerUrl);
-}
-
-static void GameServer_Initialise(auto original, void* _this, Il2CppString* sessionId, Il2CppString* gameVersion,
-                                  bool encryptRequests, Il2CppString* serverRegion)
-{
-  original(_this, sessionId, gameVersion, encryptRequests, serverRegion);
-  http::headers::primeVersion = to_string(gameVersion);
-}
-
-static void GameServer_SetInstanceIdHeader(auto original, void* _this, int32_t instanceId)
-{
-  original(_this, instanceId);
-  http::headers::instanceId = instanceId;
-}
-
-} // namespace hooks
-
-void InstallSyncPatches()
-{
-  trackers::load_previously_sent_logs();
-
-  if (auto m = GameServerModelRegistry::Method("ProcessResultInternal"))
-    SPUD_STATIC_DETOUR(m.Pointer(), hooks::GameServerModelRegistry_ProcessResultInternal);
-
-  if (auto m = PrimeApp::Class::Method("InitPrimeServer"))
-    SPUD_STATIC_DETOUR(m.Pointer(), hooks::PrimeApp_InitPrimeServer);
-
-  // This hook only captures the game version for the X-PRIME-VERSION sync header
-  // (headers::primeVersion has a static fallback). It is optional so users can turn
-  // it off when another mod detours the same method — a native and a managed detour
-  // on one prologue corrupt each other and crash at login.
-  if (!Config::Get().installGameVersionHook) {
-    spdlog::info("Sync: skipping GameServer::Initialise hook (patches.game_version = false)");
-  } else if (auto m = GameServer::Method("Initialise")) {
-    SPUD_STATIC_DETOUR(m.Pointer(), hooks::GameServer_Initialise);
-  }
-
-  if (auto m = GameServer::Method("SetInstanceIdHeader"))
-    SPUD_STATIC_DETOUR(m.Pointer(), hooks::GameServer_SetInstanceIdHeader);
-
-  // Each parser overrides ParseFinalPayload, so these are two distinct native methods.
-  if (auto m = SlotAssignRtcParser::Method("ParseFinalPayload"))
-    SPUD_STATIC_DETOUR(m.Pointer(), hooks::RtcParser_ParseFinalPayload);
-
-  if (auto m = SlotClearRtcParser::Method("ParseFinalPayload"))
-    SPUD_STATIC_DETOUR(m.Pointer(), hooks::RtcParser_ParseFinalPayload);
-
-  fleets::install();
-
-  std::thread(workers::ship_sync_data).detach();
-  std::thread(workers::ship_combat_log_data).detach();
-}
diff --git a/mods/src/patches/parts/sync/battlelogs.cc b/mods/src/patches/parts/sync/battlelogs.cc
new file mode 100644
index 000000000..aa8e740ae
--- /dev/null
+++ b/mods/src/patches/parts/sync/battlelogs.cc
@@ -0,0 +1,474 @@
+// Battle logs: the game only sends battle headers, so each new battle's journal is fetched from the game server
+// with the participants' player and alliance names resolved, then uploaded.
+
+#include "file.h"
+#include "patches/parts/sync/sync.h"
+#include "version.h"
+
+#include <Digit.PrimeServer.Models.pb.h>
+#include <cpr/cpr.h>
+#include <curl/curl.h>
+#include <spdlog/fmt/fmt.h>
+
+#include <chrono>
+#include <deque>
+#include <fstream>
+#include <memory>
+#include <optional>
+#include <ranges>
+#include <thread>
+#include <unordered_map>
+#include <unordered_set>
+
+#if _WIN32
+#include <rpc.h>
+#else
+#include <uuid/uuid.h>
+#endif
+
+namespace data_sync
+{
+namespace
+{
+  using json  = nlohmann::json;
+  using Clock = std::chrono::steady_clock;
+
+  // Battles already sent, persisted so a restart does not resend the recent ones. The game lists far fewer
+  // headers than this at a time.
+  constexpr size_t kSentBattlesKept = 300;
+
+  // Names seen in battles and profile responses, kept for [sync] resolver_cache_ttl seconds. A busy server shows
+  // a few thousand players a day; past this size, expired entries are dropped before adding more.
+  constexpr size_t kNameCacheSize = 10'000;
+
+  // Filled by the processing thread from responses the game requested and by the battle-log thread from its own
+  // requests, so it locks.
+  template <typename Key, typename Value> class NameCache
+  {
+  public:
+    std::optional<Value> Find(const Key& key)
+    {
+      std::scoped_lock lock(mutex_);
+      const auto       it = entries_.find(key);
+      if (it == entries_.end())
+        return std::nullopt;
+      if (it->second.expires_at <= Clock::now()) {
+        entries_.erase(it);
+        return std::nullopt;
+      }
+      return it->second.value;
+    }
+
+    void Store(const Key& key, Value value)
+    {
+      const auto       expires_at = Clock::now() + std::chrono::seconds(Config::Get().sync.resolver_cache_ttl);
+      std::scoped_lock lock(mutex_);
+      if (entries_.size() >= kNameCacheSize) {
+        std::erase_if(entries_, [now = Clock::now()](const auto& entry) { return entry.second.expires_at <= now; });
+        // Everything still valid (a long TTL and a lot of browsing): start over rather than grow past the bound.
+        if (entries_.size() >= kNameCacheSize)
+          entries_.clear();
+      }
+      entries_.insert_or_assign(key, Entry{std::move(value), expires_at});
+    }
+
+  private:
+    struct Entry {
+      Value             value;
+      Clock::time_point expires_at;
+    };
+    std::mutex                     mutex_;
+    std::unordered_map<Key, Entry> entries_;
+  };
+
+  struct Player {
+    std::string name;
+    int64_t     alliance = -1;
+  };
+
+  struct Alliance {
+    std::string name;
+    std::string tag;
+  };
+
+  // Shared with the processing thread and never destroyed, see sync.h.
+  auto& players   = *new NameCache<std::string, Player>;
+  auto& alliances = *new NameCache<int64_t, Alliance>;
+  auto& battles   = *new BoundedQueue<uint64_t>{"battle log", kSentBattlesKept};
+
+  // The newest kSentBattlesKept battles sent, oldest first. Loaded before the threads start, then only touched by
+  // the processing thread.
+  std::deque<uint64_t> sent_battles;
+
+  void RememberSent(uint64_t id)
+  {
+    sent_battles.push_back(id);
+    if (sent_battles.size() > kSentBattlesKept)
+      sent_battles.pop_front();
+  }
+
+  // The game's Unity build, sent as the game client sends it.
+  const std::string kUnityVersion = "6000.0.59f2-deadlock-fix-test";
+
+  // Written by game hooks on the main thread and read by the battle-log thread.
+  struct GameSession {
+    std::mutex  mutex;
+    std::string server_url;
+    std::string session_id;
+    // Until the game reports its own version.
+    std::string version     = "1.000.51336";
+    int32_t     instance_id = 0;
+  };
+  auto& session = *new GameSession;
+
+  std::string NewUuid()
+  {
+#if _WIN32
+    UUID uuid;
+    UuidCreate(&uuid);
+    unsigned char* text = nullptr;
+    UuidToStringA(&uuid, &text);
+    std::string result(reinterpret_cast<char*>(text));
+    RpcStringFreeA(&text);
+    return result;
+#else
+    uuid_t uuid;
+    uuid_generate_random(uuid);
+    char text[37];
+    uuid_unparse(uuid, text);
+    return text;
+#endif
+  }
+
+  // `base` with its path replaced, through libcurl's URL parser so ports and IDN hosts survive.
+  std::string WithPath(const std::string& base, const std::string& path)
+  {
+    std::string result = base;
+    if (auto* handle = curl_url()) {
+      char* url = nullptr;
+      if (curl_url_set(handle, CURLUPART_URL, base.c_str(), 0) == CURLUE_OK
+          && curl_url_set(handle, CURLUPART_PATH, path.c_str(), 0) == CURLUE_OK
+          && curl_url_get(handle, CURLUPART_URL, &url, CURLU_PUNYCODE) == CURLUE_OK) {
+        result = url;
+      }
+      curl_free(url);
+      curl_url_cleanup(handle);
+    }
+    return result;
+  }
+
+  // The battle-log thread's session with the game server, set up as the game client sets up its own. It is
+  // recreated when a settings reload changes the [sync] proxy or TLS check. Battle-log thread only.
+  cpr::Session& GameServer()
+  {
+    struct Session {
+      std::unique_ptr<cpr::Session> http;
+      std::string                   proxy;
+      bool                          verify_ssl = true;
+    };
+    static auto& session = *new Session; // never destroyed, see sync.h
+    const auto&  options = Config::Get().sync.options;
+    if (session.http && options.proxy == session.proxy && options.verify_ssl == session.verify_ssl)
+      return *session.http;
+
+    session.proxy      = options.proxy;
+    session.verify_ssl = options.verify_ssl;
+    session.http       = std::make_unique<cpr::Session>();
+    auto& http         = *session.http;
+    http.SetAcceptEncoding(cpr::AcceptEncoding{});
+    http.SetHttpVersion(cpr::HttpVersion{cpr::HttpVersionCode::VERSION_1_1});
+    spdlog::debug("scopely session: proxy='{}', verify_ssl={}", options.proxy, options.verify_ssl);
+    if (!options.proxy.empty())
+      http.SetProxies({{"https", options.proxy}});
+    if (!options.verify_ssl)
+      http.SetSslOptions(cpr::Ssl(cpr::ssl::VerifyHost{false}, cpr::ssl::VerifyPeer{false}, cpr::ssl::NoRevoke{true}));
+    http.SetUserAgent("UnityPlayer/" + kUnityVersion + " (UnityWebRequest/1.0, libcurl/8.10.1-DEV)");
+    http.SetHeader({
+        {"Accept", "application/json"},
+        {"Content-Type", "application/json"},
+        {"X-PRIME-SYNC", "0"},
+        {"X-Unity-Version", kUnityVersion},
+        {"X-Powered-By", "stfc community mod/" VER_FILE_VERSION_STR},
+    });
+    return http;
+  }
+
+  // POSTs to the game server as the game client would, for data the client did not request itself. Empty on
+  // error. Battle-log thread only.
+  std::string RequestGameData(const std::string& path, const std::string& body)
+  {
+    auto& http    = GameServer();
+    auto& headers = http.GetHeader();
+    {
+      std::scoped_lock lock(session.mutex);
+      http.SetUrl(WithPath(session.server_url, path));
+      headers.insert_or_assign("X-AUTH-SESSION-ID", session.session_id);
+      headers.insert_or_assign("X-PRIME-VERSION", session.version);
+      headers.insert_or_assign("X-Instance-ID", fmt::format("{:03}", session.instance_id));
+    }
+    headers.insert_or_assign("X-TRANSACTION-ID", NewUuid());
+    http.SetBody(body);
+
+    const auto response = http.Post();
+    if (response.status_code == 0) {
+      logging::error("DOWNLOAD", path, "Failed to send request: {}", response.error.message);
+      return {};
+    }
+    if (response.status_code >= 400) {
+      logging::error("DOWNLOAD", path, "Failed to communicate with server: {}", response.status_line);
+      return {};
+    }
+    const auto type = response.header.find("Content-Type");
+    logging::debug("DOWNLOAD", path, "Response: {} ({}), {:.0f} ms elapsed", response.status_line,
+                   type == response.header.end() ? "unknown" : type->second, response.elapsed * 1'000);
+    return response.text;
+  }
+
+  // The players in a battle. Fleet battles list them in deployed_fleets (fleet data with ref_ids is an NPC's);
+  // cracked stations have no fleet, so a base raid's defender only shows up in the journal's own ids.
+  std::unordered_set<std::string> Participants(const json& journal)
+  {
+    std::unordered_set<std::string> ids;
+    for (const char* side : {"target_fleet_data", "initiator_fleet_data"}) {
+      // operator[] on a const json is undefined for a missing key, so lookups go through find() and value(). A
+      // side can be null (a cracked station).
+      const auto fleet = journal.find(side);
+      if (fleet == journal.end() || !fleet->is_object() || !fleet->value("ref_ids", json()).is_null())
+        continue;
+      const auto deployed_fleets = fleet->find("deployed_fleets");
+      if (deployed_fleets == fleet->end() || !deployed_fleets->is_array())
+        continue;
+      for (const auto& deployed : *deployed_fleets)
+        if (const auto uid = deployed.find("uid"); uid != deployed.end() && uid->is_string())
+          ids.insert(uid->get<std::string>());
+    }
+    for (const char* key : {"initiator_id", "target_id"}) {
+      // NPC ids contain '_' (mar_61, npc_<id>_1); there is nothing to resolve for them.
+      if (const auto& id = journal.value(key, json());
+          id.is_string() && !id.get_ref<const std::string&>().empty()
+          && id.get_ref<const std::string&>().find('_') == std::string::npos)
+        ids.insert(id.get<std::string>());
+    }
+    return ids;
+  }
+
+  // Fetches profiles the cache does not have. A malformed profile is skipped, not the whole reply. The results are
+  // returned as well as cached, since a zero TTL expires them at once.
+  std::unordered_map<std::string, Player> FetchPlayers(const std::vector<std::string>& ids)
+  {
+    std::unordered_map<std::string, Player> fetched;
+    if (ids.empty())
+      return fetched;
+    logging::trace("PROCESS", "combat log", "Fetching {} player profiles", ids.size());
+    const auto reply =
+        json::parse(RequestGameData("/user_profile/profiles", json{{"user_ids", ids}}.dump()), nullptr, false);
+    const auto profiles = reply.is_object() ? reply.value("user_profiles", json::object()) : json::object();
+    for (const auto& [id, profile] : profiles.items()) {
+      try {
+        Player player{profile.at("name").get<std::string>(), profile.at("alliance_id").get<int64_t>()};
+        players.Store(id, player);
+        fetched.emplace(id, std::move(player));
+      } catch (const json::exception& e) {
+        spdlog::error("Failed to parse user profile {}: {}", id, e.what());
+      }
+    }
+    return fetched;
+  }
+
+  std::unordered_map<int64_t, Alliance> FetchAlliances(const std::vector<int64_t>& ids)
+  {
+    std::unordered_map<int64_t, Alliance> fetched;
+    if (ids.empty())
+      return fetched;
+    logging::trace("PROCESS", "combat log", "Fetching {} alliance profiles", ids.size());
+    const json request{{"user_current_rank", 0}, {"alliance_id", 0}, {"alliance_ids", ids}};
+    const auto reply =
+        json::parse(RequestGameData("/alliance/get_alliances_public_info", request.dump()), nullptr, false);
+    const auto infos = reply.is_object() ? reply.value("alliances_info", json::object()) : json::object();
+    for (const auto& [key, info] : infos.items()) {
+      try {
+        const auto id = info.at("id").get<int64_t>();
+        Alliance   alliance{info.at("name").get<std::string>(), info.at("tag").get<std::string>()};
+        alliances.Store(id, alliance);
+        fetched.emplace(id, std::move(alliance));
+      } catch (const json::exception& e) {
+        spdlog::error("Failed to parse alliance profile: {}", e.what());
+      }
+    }
+    return fetched;
+  }
+
+  // {player id: {name, alliance_name, alliance_tag}} for everyone in the battle, fetching what the caches lack.
+  // A player whose alliance could not be resolved keeps alliance_id instead of a name and tag. Players without an
+  // alliance (id 0 or below) are not looked up.
+  json ResolveNames(const json& journal)
+  {
+    std::unordered_map<std::string, Player> known;
+    std::vector<std::string>                missing_players;
+    for (const auto& id : Participants(journal)) {
+      if (auto player = players.Find(id))
+        known.emplace(id, std::move(*player));
+      else
+        missing_players.push_back(id);
+    }
+    known.merge(FetchPlayers(missing_players));
+
+    std::unordered_map<int64_t, Alliance> known_alliances;
+    std::unordered_set<int64_t>           missing_alliances;
+    for (const auto& player : known | std::views::values) {
+      if (player.alliance <= 0 || known_alliances.contains(player.alliance))
+        continue;
+      if (auto alliance = alliances.Find(player.alliance))
+        known_alliances.emplace(player.alliance, std::move(*alliance));
+      else
+        missing_alliances.insert(player.alliance);
+    }
+    known_alliances.merge(FetchAlliances({missing_alliances.begin(), missing_alliances.end()}));
+
+    auto names = json::object();
+    for (const auto& [id, player] : known) {
+      json       entry{{"name", player.name}, {"alliance_name", nullptr}, {"alliance_tag", nullptr}};
+      const auto alliance = known_alliances.find(player.alliance);
+      if (alliance != known_alliances.end()) {
+        entry["alliance_name"] = alliance->second.name;
+        entry["alliance_tag"]  = alliance->second.tag;
+      } else {
+        entry["alliance_id"] = player.alliance;
+      }
+      names[id] = std::move(entry);
+    }
+    return names;
+  }
+
+  void UploadBattle(uint64_t journal_id)
+  {
+    logging::trace("PROCESS", "combat log", "Fetching combat log for battle {}", journal_id);
+    const auto reply = RequestGameData("/journals/get", json{{"journal_id", journal_id}}.dump());
+    if (reply.empty())
+      return;
+    auto battle = json::parse(reply, nullptr, false);
+    if (!battle.is_object() || !battle.contains("journal")) {
+      spdlog::error("Error parsing journal response from game server for battle {}", journal_id);
+      return;
+    }
+
+    auto& journal = battle["journal"];
+    auto  names   = ResolveNames(journal);
+    Queue(SyncConfig::Type::kBattles,
+          json::array(
+              {{{"type", SyncConfig::Type::kBattles}, {"names", std::move(names)}, {"journal", std::move(journal)}}}));
+  }
+
+  void RunBattleLogs()
+  {
+    for (;;) {
+      const auto journal_id = battles.Pop();
+      try {
+        UploadBattle(journal_id);
+      } catch (const std::exception& e) {
+        spdlog::error("Error processing combat log {}: {}", journal_id, e.what());
+      } catch (...) {
+        spdlog::error("Unknown error processing combat log {}", journal_id);
+      }
+    }
+  }
+
+  void LoadSentBattles()
+  {
+    std::ifstream file(File::Path(File::Battles()), std::ios::binary);
+    if (!file) {
+      spdlog::warn("Failed to open battles file (not found or not readable); starting with empty cache");
+      return;
+    }
+    const auto ids = json::parse(file, nullptr, false);
+    if (!ids.is_array()) {
+      spdlog::error("Failed to parse battles file");
+      return;
+    }
+    for (const auto& id : ids)
+      if (id.is_number_unsigned())
+        RememberSent(id.get<uint64_t>());
+    spdlog::debug("Loaded {} previously sent battle logs", sent_battles.size());
+  }
+
+  void SaveSentBattles()
+  {
+    auto ids = json::array();
+    for (const auto id : sent_battles)
+      ids.push_back(id);
+    std::ofstream file(File::Path(File::Battles(), true), std::ios::binary | std::ios::trunc);
+    if (!file) {
+      spdlog::error("Failed to open battles file for writing");
+      return;
+    }
+    file << ids.dump();
+  }
+} // namespace
+
+void QueueNewBattles(const std::vector<uint64_t>& battle_ids)
+{
+  // Oldest first, so the oldest are forgotten first.
+  std::vector<uint64_t> fresh;
+  for (const auto id : battle_ids | std::views::reverse) {
+    if (std::ranges::find(sent_battles, id) == sent_battles.end()) {
+      RememberSent(id);
+      fresh.push_back(id);
+    }
+  }
+  if (fresh.empty())
+    return;
+
+  logging::debug("QUEUE", "battle headers", "Queuing {} battles for background processing", fresh.size());
+  for (const auto id : fresh)
+    battles.Push(id);
+  SaveSentBattles();
+}
+
+void CachePlayerNames(const std::string& bytes)
+{
+  Digit::PrimeServer::Models::UserProfilesResponse response;
+  if (!response.ParseFromString(bytes)) {
+    spdlog::error("Failed to parse user profile");
+    return;
+  }
+  for (const auto& profile : response.userprofiles())
+    players.Store(profile.userid(), {profile.name(), profile.allianceid()});
+}
+
+void CacheAllianceNames(const std::string& bytes)
+{
+  Digit::PrimeServer::Models::GetAllianceProfilesResponse response;
+  if (!response.ParseFromString(bytes)) {
+    spdlog::error("Failed to parse alliance profile");
+    return;
+  }
+  for (const auto& alliance : response.allianceprofiles())
+    if (alliance.id() > 0)
+      alliances.Store(alliance.id(), {alliance.name(), alliance.tag()});
+}
+
+void StartBattleLogs()
+{
+  LoadSentBattles();
+  std::thread(RunBattleLogs).detach();
+}
+
+void SetGameServer(std::string url, std::string session_id)
+{
+  std::scoped_lock lock(session.mutex);
+  session.server_url = std::move(url);
+  session.session_id = std::move(session_id);
+}
+
+void SetGameVersion(std::string version)
+{
+  std::scoped_lock lock(session.mutex);
+  session.version = std::move(version);
+}
+
+void SetInstanceId(int32_t instance_id)
+{
+  std::scoped_lock lock(session.mutex);
+  session.instance_id = instance_id;
+}
+} // namespace data_sync
diff --git a/mods/src/patches/parts/sync/fleets.cc b/mods/src/patches/parts/sync/fleets.cc
new file mode 100644
index 000000000..742d0b460
--- /dev/null
+++ b/mods/src/patches/parts/sync/fleets.cc
@@ -0,0 +1,281 @@
+// Live fleet state for the `fleets` category: one record per FleetState transition from fleet_watch, a full snapshot
+// as a first sync, and late re-reads after server updates. Everything that reads the game runs on the game thread
+// and only queues; uploads stay on the upload thread.
+
+#include "patches/parts/sync/sync.h"
+
+#include "patches/fleet_watch.h"
+
+#include <prime/fleet.h>
+
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <cmath>
+#include <mutex>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+namespace data_sync
+{
+namespace
+{
+  using json = nlohmann::json;
+
+  constexpr int kFleetSlotCount = 10;
+
+  // Set from any thread when another category's first sync is queued; the game thread answers with a full fleet
+  // snapshot.
+  std::atomic_bool snapshot_requested{false};
+
+  // Fleets the server just sent new data for. The client fills in some values (mining and travel timers, damage) from
+  // that data, so the game thread re-reads these fleets shortly after.
+  std::mutex                                                          reread_mutex;
+  std::unordered_map<uint64_t, std::chrono::steady_clock::time_point> reread_at;
+
+  // Set once fleet_watch accepted the subscription. Sync's frame work then drives fleet_watch.
+  bool fleet_sync_installed = false;
+
+  const char* StateName(FleetState state)
+  {
+    switch (state) {
+      case FleetState::IdleInSpace:
+        return "IdleInSpace";
+      case FleetState::Docked:
+        return "Docked";
+      case FleetState::Mining:
+        return "Mining";
+      case FleetState::Destroyed:
+        return "Destroyed";
+      case FleetState::TieringUp:
+        return "TieringUp";
+      case FleetState::Repairing:
+        return "Repairing";
+      case FleetState::Battling:
+        return "Battling";
+      case FleetState::WarpCharging:
+        return "WarpCharging";
+      case FleetState::Warping:
+        return "Warping";
+      case FleetState::Impulsing:
+        return "Impulsing";
+      case FleetState::Capturing:
+        return "Capturing";
+      case FleetState::AutoHunting:
+        return "AutoHunting";
+      case FleetState::Outposting:
+        return "Outposting";
+      default:
+        return "Unknown";
+    }
+  }
+
+  int64_t UnixSeconds()
+  {
+    return std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch())
+        .count();
+  }
+
+  template <typename T> void Put(json& out, const char* key, const std::optional<T>& value)
+  {
+    if (value)
+      out[key] = *value;
+  }
+
+  // Absent objects and unset times are left out; members missing from the client read as zero.
+  void AddLiveState(json& out, FleetPlayerData* fleet, FleetState state)
+  {
+    const auto is_mining    = fleet->IsMining();
+    const auto is_repairing = fleet->IsRepairing();
+
+    const auto is_home      = fleet->IsHome();
+    const auto is_destroyed = fleet->IsDestroyed();
+
+    out["is_home"]      = is_home;
+    out["is_deployed"]  = fleet->IsDeployed();
+    out["is_mining"]    = is_mining;
+    out["is_repairing"] = is_repairing;
+    out["is_damaged"]   = fleet->IsDamaged();
+    out["is_destroyed"] = is_destroyed;
+    out["drydock"]      = fleet->DrydockID();
+    // The client only updates this at the station; in space the server's hull points are the live value.
+    if (is_home || is_destroyed)
+      if (const auto damage = fleet->HullDamage())
+        out["hull_damage"] = std::llround(*damage);
+    out["cargo_fill"] = fleet->CargoResourceFillLevel();
+
+    if (auto* hold = fleet->CargoHold()) {
+      if (auto* current = hold->CurrentCargo()) {
+        out["cargo"]     = current->CurrentValue();
+        out["cargo_max"] = current->MaxValue();
+      }
+      if (auto* protected_cargo = hold->ProtectedCargoProgress())
+        out["protected_cargo"] = protected_cargo->CurrentValue();
+    }
+
+    if (is_mining) {
+      if (auto* slot = fleet->MiningData()) {
+        out["node_id"]       = slot->ParentId();
+        out["node_resource"] = slot->ResourceId();
+        out["amount_mined"]  = slot->AmountMined();
+        Put(out, "occupied_since", slot->OccupyTimeUtc().UnixSeconds());
+        if (auto* node = slot->PointData())
+          out["node_amount"] = node->Amount();
+      }
+      out["mining_rate"] = fleet->GetMiningRate();
+      if (auto* timer = fleet->MiningSlotTimer())
+        Put(out, "mining_due", timer->DueTime().UnixSeconds());
+    }
+
+    if (is_repairing)
+      if (auto* timer = fleet->Timer())
+        Put(out, "repair_due", timer->DueTime().UnixSeconds());
+
+    if (state == FleetState::WarpCharging || state == FleetState::Warping || state == FleetState::Impulsing)
+      if (auto* timer = fleet->Timer())
+        Put(out, "travel_due", timer->DueTime().UnixSeconds());
+  }
+
+  // The values the client fills in late, as last sent per fleet; a re-read is only sent when they changed. Values
+  // that move on their own are left out: cargo while mining, hull while repairing.
+  std::unordered_map<uint64_t, size_t> sent_late;
+
+  size_t LateFields(const json& record)
+  {
+    auto fields = json::object();
+    for (const auto* key : {"is_damaged", "is_destroyed", "is_repairing", "repair_due", "travel_due", "hull_damage",
+                            "mining_due", "node_id", "cargo_max"})
+      if (const auto it = record.find(key); it != record.end())
+        fields[key] = *it;
+    if (record.value("is_repairing", false))
+      fields.erase("hull_damage");
+    return std::hash<json>{}(fields);
+  }
+
+  // Reads a FleetPlayerData that is valid for the current frame.
+  json Record(int slot, FleetPlayerData* fleet, FleetState state, FleetState previous)
+  {
+    auto* hull = fleet->Hull();
+    // Hull ids are 32-bit and run past 2^31 (e.g. Kumari 3005922948); take the value as unsigned before widening so
+    // those never come out negative in the record.
+    const int64_t hull_id = hull ? static_cast<int64_t>(static_cast<uint32_t>(hull->Id())) : 0;
+
+    json out = {{"type", SyncConfig::Type::kFleets},
+                {"fid", fleet->Id()},
+                {"slot", slot},
+                {"hull_id", hull_id},
+                {"level", fleet->Level()},
+                {"state", static_cast<int>(state)},
+                {"state_name", StateName(state)},
+                {"prev_state", static_cast<int>(previous)},
+                {"prev_state_name", StateName(previous)},
+                {"t", UnixSeconds()},
+                {"src", "client"}};
+    AddLiveState(out, fleet, state);
+    sent_late[fleet->Id()] = LateFields(out);
+    return out;
+  }
+
+  // A snapshot is the complete list of occupied slots, so it is sent as a first sync.
+  void QueueSnapshot(const char* reason)
+  {
+    auto* manager = FleetsManager::Instance();
+    if (!manager || !manager->HasFleetService())
+      return;
+
+    auto records = json::array();
+    for (int slot = 0; slot < kFleetSlotCount; ++slot)
+      if (auto* fleet = manager->GetFleetPlayerData(slot))
+        records.push_back(Record(slot, fleet, fleet->CurrentState(), fleet->PreviousState()));
+
+    if (!records.empty()) {
+      logging::debug("PROCESS", "fleets", "Fleet snapshot ({}): {} fleets", reason, records.size());
+      Queue(SyncConfig::Type::kFleets, records, true);
+    }
+  }
+
+  // Each transition is its own upload, so Mining -> Docked -> Repairing between two uploads still sends all three.
+  void OnTransition(const fleet_watch::Transition& transition)
+  {
+    if (!transition.fleet)
+      return;
+    auto records = json::array();
+    records.push_back(Record(transition.after.slot, transition.fleet, transition.after.state, transition.before.state));
+    Queue(SyncConfig::Type::kFleets, records);
+  }
+
+  void OnBaseline()
+  {
+    snapshot_requested.store(false, std::memory_order_relaxed);
+    QueueSnapshot("baseline");
+  }
+
+  void RereadDue()
+  {
+    std::vector<uint64_t> due;
+    {
+      std::scoped_lock lock(reread_mutex);
+      if (reread_at.empty())
+        return;
+      const auto now = std::chrono::steady_clock::now();
+      std::erase_if(reread_at, [&](const auto& entry) {
+        if (entry.second > now)
+          return false;
+        due.push_back(entry.first);
+        return true;
+      });
+    }
+    if (due.empty())
+      return;
+
+    auto* manager = FleetsManager::Instance();
+    if (!manager || !manager->HasFleetService())
+      return;
+
+    auto records = json::array();
+    for (int slot = 0; slot < kFleetSlotCount; ++slot) {
+      auto* fleet = manager->GetFleetPlayerData(slot);
+      if (!fleet || std::ranges::find(due, fleet->Id()) == due.end())
+        continue;
+      const auto before = sent_late[fleet->Id()];
+      auto       record = Record(slot, fleet, fleet->CurrentState(), fleet->PreviousState());
+      if (LateFields(record) != before)
+        records.push_back(std::move(record));
+    }
+    if (!records.empty())
+      Queue(SyncConfig::Type::kFleets, records);
+  }
+} // namespace
+
+void InstallFleetSync()
+{
+  if (!Config::Get().sync.options.fleets)
+    return;
+  if (!fleet_watch::Subscribe({.on_transition = OnTransition, .on_baseline = OnBaseline})) {
+    spdlog::warn("Sync: fleet state subscriber could not be installed; fleet sync disabled");
+    return;
+  }
+  fleet_sync_installed = true;
+  spdlog::info("Sync: fleet state sync enabled");
+}
+
+void RequestFleetSnapshot()
+{ snapshot_requested.store(true, std::memory_order_release); }
+
+void RereadFleet(uint64_t fleet_id)
+{
+  std::scoped_lock lock(reread_mutex);
+  reread_at.try_emplace(fleet_id, std::chrono::steady_clock::now() + std::chrono::seconds(1));
+}
+
+void UpdateFleetSync()
+{
+  if (!fleet_sync_installed)
+    return;
+  fleet_watch::Tick();
+  RereadDue();
+  if (snapshot_requested.load(std::memory_order_relaxed) && snapshot_requested.exchange(false))
+    QueueSnapshot("first sync");
+}
+} // namespace data_sync
diff --git a/mods/src/patches/parts/sync/records.cc b/mods/src/patches/parts/sync/records.cc
new file mode 100644
index 000000000..60931ed55
--- /dev/null
+++ b/mods/src/patches/parts/sync/records.cc
@@ -0,0 +1,1217 @@
+// What each data category sends: the processors that turn the game's server responses and realtime messages into
+// the records sync targets receive. Each keeps the last state it sent per record, so only changes go out. They all
+// run on the processing thread, in the order the game received the data.
+
+#include "patches/parts/sync/sync.h"
+#include "str_utils.h"
+#include "prime/UserProfileManager.h"
+
+#include <Digit.PrimePlatform.Content.pb.h>
+#include <Digit.PrimeServer.Models.pb.h>
+#include <stfc.sync.pb.h>
+#include <google/protobuf/repeated_field.h>
+#include <spdlog/fmt/fmt.h>
+
+#include <algorithm>
+#include <charconv>
+#include <chrono>
+#include <cmath>
+#include <optional>
+#include <ranges>
+#include <tuple>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+template <typename T> struct adl_serializer<google::protobuf::RepeatedField<T>> {
+  static void to_json(json& j, const google::protobuf::RepeatedField<T>& proto)
+  {
+    j = json::array();
+    for (const auto& v : proto)
+      j.push_back(v);
+  }
+};
+NLOHMANN_JSON_NAMESPACE_END
+
+namespace data_sync
+{
+namespace
+{
+  using json        = nlohmann::json;
+  namespace pb      = Digit::PrimeServer::Models;
+  namespace content = Digit::PrimePlatform::Content;
+
+  struct PairHash {
+    template <typename T, typename U> size_t operator()(const std::pair<T, U>& pair) const
+    { return std::hash<T>()(pair.first) ^ (std::hash<U>()(pair.second) << 1); }
+  };
+
+  // The last value sent for each record of one category, so only changes are uploaded. Everything below runs on
+  // the processing thread, so none of it is locked.
+  template <typename Key, typename Value, typename Hash = std::hash<Key>> class SentState
+  {
+  public:
+    // Records `value` and reports whether it differs from what was last sent.
+    bool Changed(const Key& key, const Value& value)
+    {
+      auto [it, inserted] = sent_.try_emplace(key, value);
+      if (inserted)
+        return true;
+      if (it->second == value)
+        return false;
+      it->second = value;
+      return true;
+    }
+
+    // Forgets every record not in `present` and calls `gone` for each.
+    template <typename Present, typename Gone> void Prune(const Present& present, Gone&& gone)
+    {
+      std::erase_if(sent_, [&](const auto& entry) {
+        if (present.contains(entry.first))
+          return false;
+        gone(entry.first);
+        return true;
+      });
+    }
+
+  private:
+    std::unordered_map<Key, Value, Hash> sent_;
+  };
+
+  // Each category's first upload in a session is marked as a full sync for the targets.
+  struct FirstSync {
+    bool pending = true;
+    bool Take()
+    { return std::exchange(pending, false); }
+  };
+
+  // The changed records of one category, queued for upload in one request.
+  class Batch
+  {
+  public:
+    explicit Batch(SyncConfig::Type type)
+        : type_(type)
+    {
+    }
+
+    void Add(json record)
+    { records_.push_back(std::move(record)); }
+
+    void Send(FirstSync* first = nullptr)
+    {
+      if (!records_.empty())
+        Queue(type_, records_, first && first->Take());
+    }
+
+  private:
+    SyncConfig::Type type_;
+    json             records_ = json::array();
+  };
+
+  template <typename Message> std::optional<Message> Parse(const std::string& bytes, std::string_view what)
+  {
+    Message message;
+    if (message.ParseFromString(bytes))
+      return message;
+    spdlog::error("Failed to parse {}", what);
+    return std::nullopt;
+  }
+
+  void Trace(std::string_view what, size_t count)
+  { logging::trace("PROCESS", what, "Processing {}", count); }
+
+  // Officers and forbidden tech: rank or tier, level, shards.
+  using RankLevelShards = std::tuple<int32_t, int32_t, int32_t>;
+
+  struct ShipState {
+    int32_t              tier;
+    int32_t              level;
+    double               level_percentage;
+    std::vector<int64_t> components;
+
+    // Level progress jitters in the last digits; only a real change is worth an upload.
+    bool operator==(const ShipState& other) const
+    {
+      return tier == other.tier && level == other.level && std::fabs(level_percentage - other.level_percentage) < 0.01
+             && components == other.components;
+    }
+  };
+
+  // Everything the processing thread remembers about this session. A new login starts it over.
+  struct SentData {
+    SentState<int64_t, int64_t>                               modules, resources, alliance_resources, slots;
+    SentState<int64_t, int64_t> haven_pieces;
+    SentState<int64_t, std::tuple<int32_t, int32_t, int64_t>> haven_map_buildings;
+    SentState<int64_t, std::pair<int32_t, int64_t>>           buffs;
+    SentState<std::pair<int32_t, int64_t>, int64_t, PairHash> inventory;
+    SentState<std::string, bool>                              active_jobs;
+    SentState<uint64_t, RankLevelShards>                      officers, techs;
+    SentState<int64_t, int32_t>                               research;
+    SentState<std::pair<int64_t, int64_t>, int32_t, PairHash> traits;
+    SentState<int64_t, ShipState>                             ships;
+    SentState<int64_t, size_t>                                away_assignments;
+    // A hash of each deployed fleet's server record.
+    SentState<int64_t, size_t>                                deployed_fleets;
+    std::unordered_set<int64_t>                               active_missions, completed_missions;
+    // The first active mission list of a session is always sent, even empty, so a target can drop stale ones.
+    bool    active_missions_sent = false;
+    int32_t emerald_chain_level  = -1;
+    // The last store offers snapshot sent.
+    json store_offers;
+    // The protobuf and JSON resource lists are flagged separately, as two different first uploads.
+    FirstSync first_away_assignments, first_buffs, first_inventory, first_jobs, first_resources, first_json_resources,
+        first_alliance_resources, first_ships, first_profile, first_haven_pieces, first_haven_map;
+    // The own profile's last level, Power and Haven unlock sent. XP rides along but is not part of the key: an
+    // XP-only change waits for the next keyed change.
+    std::optional<std::tuple<int32_t, uint64_t, bool>> own_profile;
+  };
+  // Processing thread only, so not locked. Never destroyed, see sync.h.
+  auto& sent = *new SentData;
+
+  // An away assignment is compared by a hash of its whole record: officers, state, job, traits and chances.
+  void AddAwayAssignment(Batch& batch, const pb::AwayAssignmentInstance& instance)
+  {
+    // officerIds is a protobuf map, whose order is not slot order. Sorting keeps the array, and so the hash, stable.
+    std::vector<std::pair<int64_t, int64_t>> officer_slots(instance.officerids().begin(), instance.officerids().end());
+    std::ranges::sort(officer_slots, {}, &std::pair<int64_t, int64_t>::first);
+    auto officer_ids = json::array();
+    for (const auto& [slot, officer] : officer_slots)
+      if (officer != 0)
+        officer_ids.push_back(officer);
+
+    auto officer_traits = json::array();
+    for (const auto& trait : instance.officertraits())
+      officer_traits.push_back({{"tid", trait.traitid()}, {"max_level", trait.maxlevel()}});
+
+    // Same ordering concern as officer_ids: sort by trait id so the array and the de-dup hash are stable.
+    std::vector<std::pair<int64_t, int32_t>> critical_traits(instance.parameters().criticaltraitscores().begin(),
+                                                             instance.parameters().criticaltraitscores().end());
+    std::ranges::sort(critical_traits, {}, &std::pair<int64_t, int32_t>::first);
+    auto critical_trait_scores = json::array();
+    for (const auto& [tid, score] : critical_traits)
+      critical_trait_scores.push_back({{"tid", tid}, {"score", score}});
+
+    // The chances are in the de-dup hash, so an assignment is sent again when they change.
+    json record{{"type", SyncConfig::Type::kAwayAssignments},
+                {"aid", instance.id()},
+                {"template_id", instance.awayassignmenttemplateid()},
+                {"state", instance.state()},
+                {"officer_ids", officer_ids},
+                {"job_uuid", instance.jobuuid()},
+                {"duration", instance.parameters().duration()},
+                {"rarity", instance.rarity()},
+                {"officer_traits", officer_traits},
+                {"critical_trait_scores", critical_trait_scores},
+                {"success_chance", instance.parameters().successchance()},
+                {"critical_success_chance", instance.parameters().criticalsuccesschance()},
+                {"max_critical_success_chance", instance.maxcriticalsuccesschance()},
+                {"key_stat", instance.keystat()},
+                {"max_assignable_officers", instance.maxassignableofficerscount()},
+                {"attack_weight", instance.attackweight()},
+                {"defense_weight", instance.defenseweight()},
+                {"health_weight", instance.healthweight()}};
+    if (sent.away_assignments.Changed(instance.id(), std::hash<json>{}(record)))
+      batch.Add(std::move(record));
+  }
+
+  // The full list. An assignment that left it was collected.
+  void ProcessAwayAssignments(const std::string& bytes)
+  {
+    auto response = Parse<pb::AwayAssignmentUserListResponse>(bytes, "away assignments");
+    if (!response)
+      return;
+    Trace("away assignments", response->instances_size());
+
+    Batch                       batch(SyncConfig::Type::kAwayAssignments);
+    std::unordered_set<int64_t> present;
+    for (const auto& instance : response->instances()) {
+      present.insert(instance.id());
+      AddAwayAssignment(batch, instance);
+    }
+    sent.away_assignments.Prune(present, [&](int64_t id) {
+      batch.Add({{"type", "collected_" + SyncConfig::Type::kAwayAssignments}, {"aid", id}});
+    });
+    batch.Send(&sent.first_away_assignments);
+  }
+
+  // One assignment as it starts: first ready to start with its officers set, then in progress with its job.
+  void ProcessAwayAssignment(const std::string& bytes)
+  {
+    auto instance = Parse<pb::AwayAssignmentInstance>(bytes, "away assignment instance");
+    if (!instance)
+      return;
+    logging::trace("PROCESS", "away assignment", "Processing away assignment {}", instance->id());
+
+    Batch batch(SyncConfig::Type::kAwayAssignments);
+    AddAwayAssignment(batch, *instance);
+    batch.Send();
+  }
+
+  void ProcessBattleHeaders(const std::string& bytes)
+  {
+    auto response = Parse<pb::BattleResultHeadersResponse>(bytes, "battle result headers");
+    if (!response)
+      return;
+    Trace("battle headers", response->headers_size());
+
+    std::vector<uint64_t> battle_ids;
+    for (const auto& header : response->headers())
+      battle_ids.push_back(static_cast<uint64_t>(header.id()));
+    QueueNewBattles(battle_ids);
+  }
+
+  void ProcessBuffs(const std::string& bytes)
+  {
+    auto response = Parse<pb::GlobalActiveBuffsResponse>(bytes, "global active buffs");
+    if (!response)
+      return;
+    Trace("global buffs", response->globalactivebuffs_size());
+
+    Batch                       batch(SyncConfig::Type::kBuffs);
+    std::unordered_set<int64_t> present;
+    for (const auto& buff : response->globalactivebuffs()) {
+      present.insert(buff.buffid());
+      const bool    expires = buff.has_activebuff() && buff.activebuff().has_expirytime();
+      const int64_t expiry  = expires ? buff.activebuff().expirytime().seconds() : -1;
+      if (sent.buffs.Changed(buff.buffid(), {buff.level(), expiry}))
+        batch.Add({{"type", SyncConfig::Type::kBuffs},
+                   {"bid", buff.buffid()},
+                   {"level", buff.level()},
+                   {"expiry_time", expires ? json(expiry) : json(nullptr)}});
+    }
+    sent.buffs.Prune(present,
+                     [&](int64_t id) { batch.Add({{"type", "expired_" + SyncConfig::Type::kBuffs}, {"bid", id}}); });
+    batch.Send(&sent.first_buffs);
+  }
+
+  // The emerald chain level is the highest tier the alliance has claimed.
+  void ProcessAllianceGameProperties(const std::string& bytes)
+  {
+    auto response = Parse<pb::AllianceGamePropertiesResponse>(bytes, "alliance games properties");
+    if (!response)
+      return;
+
+    for (const auto& property : response->properties()) {
+      if (property.propertyname() != "claimed_loyalty_tiers")
+        continue;
+      int32_t level = -1;
+      for (const auto& tier : property.valuelist()) {
+        int32_t value = -1;
+        std::from_chars(tier.data(), tier.data() + tier.size(), value);
+        level = std::max(level, value);
+      }
+      if (level != std::exchange(sent.emerald_chain_level, level)) {
+        Batch batch(SyncConfig::Type::kEmeraldChain);
+        batch.Add({{"type", SyncConfig::Type::kEmeraldChain}, {"level", level}});
+        batch.Send();
+      }
+      return;
+    }
+  }
+
+  void ProcessStarbaseModules(const std::string& bytes)
+  {
+    auto response = Parse<pb::StarbaseModulesResponse>(bytes, "starbase modules");
+    if (!response)
+      return;
+    Trace("starbase modules", response->modulestates_size());
+
+    Batch batch(SyncConfig::Type::kBuildings);
+    for (const auto& module : response->modulestates())
+      if (sent.modules.Changed(module.id(), module.level()))
+        batch.Add({{"type", SyncConfig::Type::kBuildings}, {"bid", module.id()}, {"level", module.level()}});
+    batch.Send();
+  }
+
+  void ProcessHavenBase(const std::string& bytes)
+  {
+    auto response = Parse<pb::PlanetaryBase>(bytes, "planetary base");
+    if (!response)
+      return;
+    Trace("planetary base data", response->pieces_size());
+
+    Batch batch(SyncConfig::Type::kHaven);
+    for (const auto& [piece, count] : response->pieces())
+      if (sent.haven_pieces.Changed(piece, count))
+        batch.Add({{"type", SyncConfig::Type::kHaven + "_pieces"}, {"sid", piece}, {"count", count}});
+    batch.Send(&sent.first_haven_pieces);
+  }
+
+  void ProcessHavenMap(const std::string& bytes)
+  {
+    auto response = Parse<pb::PlanetaryMapData>(bytes, "planetary map");
+    if (!response)
+      return;
+    Trace("planetary map data", response->buildings_size());
+
+    Batch batch(SyncConfig::Type::kHaven);
+    for (const auto& [id, building] : response->buildings())
+      if (sent.haven_map_buildings.Changed(id, {building.level(), static_cast<int32_t>(building.status()), building.position()}))
+        batch.Add({{"type", SyncConfig::Type::kHaven}, {"sid", building.specid()}, {"id", id},
+                   {"level", building.level()}, {"status", building.status()}, {"position", building.position()}});
+    batch.Send(&sent.first_haven_map);
+  }
+
+  void ProcessHavenMapResponse(const std::string& bytes)
+  {
+    auto response = Parse<pb::PlanetaryMapResponse>(bytes, "planetary map response");
+    if (!response)
+      return;
+    const auto& owner = response->owneruserid();
+    if (!owner.empty()) {
+      auto* profile = LocalUserProfile();
+      auto* user_id = profile ? profile->UserId() : nullptr;
+      if (!user_id || owner != il2cpp::ToUtf8(user_id))
+        return;
+    }
+    Batch batch(SyncConfig::Type::kHaven);
+    for (const auto& [id, building] : response->mapdata().buildings())
+      if (sent.haven_map_buildings.Changed(id, {building.level(), static_cast<int32_t>(building.status()), building.position()}))
+        batch.Add({{"type", SyncConfig::Type::kHaven}, {"sid", building.specid()}, {"id", id},
+                   {"level", building.level()}, {"status", building.status()}, {"position", building.position()}});
+    batch.Send(&sent.first_haven_map);
+  }
+
+  void ProcessHavenProsperity(const std::string& bytes)
+  {
+    auto response = Parse<pb::PlanetaryMapProsperityResponse>(bytes, "planetary map prosperity");
+    if (!response)
+      return;
+
+    Batch batch(SyncConfig::Type::kHaven);
+    batch.Add({{"type", SyncConfig::Type::kHaven + "_prosperity"}, {"prosperity", response->prosperity()}});
+    batch.Send();
+  }
+
+  void ProcessInventory(const std::string& bytes)
+  {
+    auto response = Parse<pb::InventoryResponse>(bytes, "player inventories");
+    if (!response)
+      return;
+    Trace("player inventories", response->inventories_size());
+
+    Batch batch(SyncConfig::Type::kInventory);
+    for (const auto& items : response->inventories() | std::views::values) {
+      for (const auto& item : items.items()) {
+        if (!item.has_commonparams())
+          continue;
+        const auto id = item.commonparams().refid();
+        if (sent.inventory.Changed({item.type(), id}, item.count()))
+          batch.Add({{"type", SyncConfig::Type::kInventory},
+                     {"item_type", item.type()},
+                     {"refid", id},
+                     {"count", item.count()}});
+      }
+    }
+    batch.Send(&sent.first_inventory);
+  }
+
+  // The fields that identify what a job is working on, or nothing for job types that are not synced.
+  std::optional<json> JobDetails(const pb::Job& job)
+  {
+    switch (job.type()) {
+      case pb::JOBTYPE_RESEARCH:
+        return json{{"rid", job.researchparams().projectid()}, {"level", job.researchparams().level()}};
+      case pb::JOBTYPE_STARBASECONSTRUCTION:
+        return json{{"bid", job.starbaseconstructionparams().moduleid()},
+                    {"level", job.starbaseconstructionparams().level()}};
+      case pb::JOBTYPE_SHIPTIERUP:
+        return json{{"psid", job.tierupshipparams().shipid()}, {"tier", job.tierupshipparams().newtier()}};
+      case pb::JOBTYPE_SHIPSCRAP:
+        return json{{"psid", job.scrapyardparams().shipid()},
+                    {"hull_id", job.scrapyardparams().hullid()},
+                    {"level", job.scrapyardparams().level()}};
+      case pb::JOBTYPE_AWAYASSIGNMENT:
+        return json{{"aid", job.awayassignmentparams().awayassignmentinstanceid()}};
+      // Part of fleet sync: jobs-only targets see nothing new. The repair changes the fleet's state later, so the
+      // fleet is re-read then.
+      case pb::JOBTYPE_REPAIRFLEET:
+        if (!Config::Get().sync.options.fleets)
+          return std::nullopt;
+        RereadFleet(job.repairfleetparams().fleetid());
+        return json{{"fid", job.repairfleetparams().fleetid()}};
+      default:
+        return std::nullopt;
+    }
+  }
+
+  // Jobs are sent when they start and reported completed when they leave the list.
+  void ProcessJobs(const std::string& bytes)
+  {
+    auto response = Parse<pb::JobResponse>(bytes, "jobs");
+    if (!response)
+      return;
+    Trace("jobs", response->jobs_size());
+
+    Batch                           batch(SyncConfig::Type::kJobs);
+    std::unordered_set<std::string> present;
+    for (const auto& job : response->jobs()) {
+      present.insert(job.uuid());
+      if (!sent.active_jobs.Changed(job.uuid(), true))
+        continue;
+      auto details = JobDetails(job);
+      if (!details)
+        continue;
+      json record{{"type", SyncConfig::Type::kJobs},
+                  {"job_type", job.type()},
+                  {"uuid", job.uuid()},
+                  {"start_time", job.starttime().seconds()},
+                  {"duration", job.duration()},
+                  {"reduction", job.reductioninseconds()}};
+      record.update(*details);
+      batch.Add(std::move(record));
+    }
+    sent.active_jobs.Prune(present, [&](const std::string& uuid) {
+      batch.Add({{"type", "completed_" + SyncConfig::Type::kJobs}, {"uuid", uuid}});
+    });
+    batch.Send(&sent.first_jobs);
+  }
+
+  // The whole set of active missions is sent whenever it changes; an empty set as one record with a null "mid".
+  void ProcessActiveMissions(const std::string& bytes)
+  {
+    auto response = Parse<pb::ActiveMissionsResponse>(bytes, "active missions");
+    if (!response)
+      return;
+    Trace("active missions", response->activemissions_size());
+
+    std::unordered_set<int64_t> current;
+    for (const auto& mission : response->activemissions())
+      current.insert(mission.id());
+    if (sent.active_missions_sent && current == sent.active_missions)
+      return;
+    sent.active_missions_sent = true;
+    sent.active_missions      = std::move(current);
+
+    Batch batch(SyncConfig::Type::kMissions);
+    for (const auto mission : sent.active_missions)
+      batch.Add({{"type", "active_" + SyncConfig::Type::kMissions}, {"mid", mission}});
+    // An empty set has no records to send, so targets would keep showing the last mission active. One record with
+    // a null mission id stands for "no active missions".
+    if (sent.active_missions.empty())
+      batch.Add({{"type", "active_" + SyncConfig::Type::kMissions}, {"mid", nullptr}});
+    batch.Send();
+  }
+
+  // Completed missions only grow, so only the new ones are sent.
+  void ProcessCompletedMissions(const std::string& bytes)
+  {
+    auto response = Parse<pb::CompletedMissionsResponse>(bytes, "completed missions");
+    if (!response)
+      return;
+    Trace("completed missions", response->completedmissions_size());
+
+    Batch batch(SyncConfig::Type::kMissions);
+    for (const auto mission : response->completedmissions())
+      if (sent.completed_missions.insert(mission).second)
+        batch.Add({{"type", SyncConfig::Type::kMissions}, {"mid", mission}});
+    batch.Send();
+  }
+
+  void ProcessOfficers(const std::string& bytes)
+  {
+    auto response = Parse<pb::OfficersResponse>(bytes, "officers");
+    if (!response)
+      return;
+    Trace("officers", response->officers_size());
+
+    Batch batch(SyncConfig::Type::kOfficer);
+    for (const auto& officer : response->officers())
+      if (sent.officers.Changed(officer.id(), {officer.rankindex(), officer.level(), officer.shardcount()}))
+        batch.Add({{"type", SyncConfig::Type::kOfficer},
+                   {"oid", officer.id()},
+                   {"rank", officer.rankindex()},
+                   {"level", officer.level()},
+                   {"shard_count", officer.shardcount()}});
+    batch.Send();
+  }
+
+  void ProcessResearch(const std::string& bytes)
+  {
+    auto response = Parse<pb::ResearchTreesState>(bytes, "research trees state");
+    if (!response)
+      return;
+    Trace("research projects", response->researchprojectlevels_size());
+
+    Batch batch(SyncConfig::Type::kResearch);
+    for (const auto& [id, level] : response->researchprojectlevels())
+      if (sent.research.Changed(id, level))
+        batch.Add({{"type", SyncConfig::Type::kResearch}, {"rid", id}, {"level", level}});
+    batch.Send();
+  }
+
+  // Resource amounts arrive as full lists and as deltas, for the player and the alliance bank. All feed the same
+  // last-sent state per owner, which is why every response goes through one thread in order.
+  void AddResource(Batch& batch, SentState<int64_t, int64_t>& state, std::string_view prefix, int64_t id,
+                   int64_t amount)
+  {
+    if (state.Changed(id, amount))
+      batch.Add(
+          {{"type", std::string(prefix) + to_string(SyncConfig::Type::kResources)}, {"rid", id}, {"amount", amount}});
+  }
+
+  void ProcessResources(const std::string& bytes)
+  {
+    auto response = Parse<pb::ResourcesResponse>(bytes, "resources");
+    if (!response)
+      return;
+    Trace("resources", response->resources_size());
+
+    Batch batch(SyncConfig::Type::kResources);
+    for (const auto& resource : response->resources())
+      AddResource(batch, sent.resources, "", resource.id(), resource.currentamount());
+    batch.Send(&sent.first_resources);
+  }
+
+  void ProcessResourcesDelta(const std::string& bytes)
+  {
+    auto response = Parse<pb::ResourcesDeltaResponse>(bytes, "resources delta");
+    if (!response)
+      return;
+    Trace("resource changes", response->resources_size());
+
+    Batch batch(SyncConfig::Type::kResources);
+    for (const auto& resource : response->resources())
+      AddResource(batch, sent.resources, "", resource.id(), resource.amount());
+    batch.Send();
+  }
+
+  void ProcessAllianceResources(const std::string& bytes)
+  {
+    auto response = Parse<pb::AllianceGetBankResourcesResponse>(bytes, "alliance resources");
+    if (!response)
+      return;
+    Trace("alliance resources", response->items_size());
+
+    Batch batch(SyncConfig::Type::kResources);
+    for (const auto& item : response->items())
+      if (item.has_commonparams())
+        AddResource(batch, sent.alliance_resources, "alliance_", item.commonparams().refid(), item.count());
+    batch.Send(&sent.first_alliance_resources);
+  }
+
+  void ProcessAllianceResourcesDelta(const std::string& bytes)
+  {
+    auto response = Parse<pb::AllianceResourcesDeltaResponse>(bytes, "alliance resources delta");
+    if (!response)
+      return;
+    Trace("alliance resource changes", response->resources_size());
+
+    Batch batch(SyncConfig::Type::kResources);
+    for (const auto& resource : response->resources())
+      AddResource(batch, sent.alliance_resources, "alliance_", resource.id(), resource.amount());
+    batch.Send();
+  }
+
+  // Slots change through server responses and through realtime messages, which describe the same slot in
+  // different shapes. Both reduce it to its params and one state value: the item id, or a hash of the params
+  // for slot types whose params are the content.
+  void AddSlot(Batch& batch, int64_t id, int32_t slot_type, const json& spec_id, const json& item_id,
+               const json& params, int64_t state)
+  {
+    if (sent.slots.Changed(id, state))
+      batch.Add({{"type", SyncConfig::Type::kSlots},
+                 {"sid", id},
+                 {"slot_type", slot_type},
+                 {"spec_id", spec_id},
+                 {"item_id", item_id},
+                 {"params", params}});
+  }
+
+  int64_t Hash(const json& params)
+  { return static_cast<int64_t>(std::hash<json>{}(params)); }
+
+  json Seconds(bool has, int64_t seconds)
+  { return has ? json(seconds) : json(nullptr); }
+
+  void AddSlot(Batch& batch, const pb::EntitySlot& slot)
+  {
+    json    params;
+    int64_t state = slot.has_slotitemid() ? slot.slotitemid().value() : -1;
+    switch (slot.slottype()) {
+      case pb::SLOTTYPE_CONSUMABLE:
+        if (slot.has_consumableslotparams()) {
+          const auto& consumable = slot.consumableslotparams();
+          params["expiry_time"]  = Seconds(consumable.has_expirytime(), consumable.expirytime().seconds());
+        }
+        break;
+      case pb::SLOTTYPE_OFFICERPRESET:
+        if (slot.has_officerpresetslotparams()) {
+          const auto& preset = slot.officerpresetslotparams();
+          params = {{"name", preset.name()}, {"order", preset.order()}, {"officer_ids", preset.officerids()}};
+          state  = Hash(params);
+        }
+        break;
+      case pb::SLOTTYPE_FLEETCOMMANDER:
+        if (slot.has_fleetcommanderslotparams())
+          params["order"] = slot.fleetcommanderslotparams().order();
+        break;
+      case pb::SLOTTYPE_SELECTABLESKILL:
+        if (slot.has_selectableskillslotparams()) {
+          const auto& skill             = slot.selectableskillslotparams();
+          params["cooldown_expiration"] = Seconds(skill.has_cooldownexpiration(), skill.cooldownexpiration().seconds());
+        }
+        break;
+      case pb::SLOTTYPE_FORBIDDENTECH:
+        if (slot.has_forbiddentechslotparams()) {
+          const auto& tech = slot.forbiddentechslotparams();
+          params           = {{"owner_id", tech.ownerid()}, {"tier", tech.tier()}, {"level", tech.level()}};
+          state            = Hash(params);
+        }
+        break;
+      case pb::SLOTTYPE_FLEETPRESET:
+        if (slot.has_fleetpresetslotparams()) {
+          const auto& preset = slot.fleetpresetslotparams();
+          auto        setups = json::array();
+          for (const auto& setup : preset.setups())
+            setups.push_back({{"drydock_id", setup.drydockid()},
+                              {"ship_id", setup.shipids_size() > 0 ? json(setup.shipids(0)) : json(nullptr)},
+                              {"officer_ids", setup.officerids()}});
+          params = {{"name", preset.name()}, {"order", preset.order()}, {"setup", setups}};
+          state  = Hash(params);
+        }
+        break;
+      default:
+        return;
+    }
+    AddSlot(batch, slot.id(), slot.slottype(), slot.slotspecid(),
+            slot.has_slotitemid() ? json(slot.slotitemid().value()) : json(nullptr), params, state);
+  }
+
+  void ProcessEntitySlots(const std::string& bytes)
+  {
+    auto response = Parse<pb::EntitySlots>(bytes, "entity slots");
+    if (!response)
+      return;
+    Trace("entity slots", response->entityslots__size());
+
+    Batch batch(SyncConfig::Type::kSlots);
+    for (const auto& slot : response->entityslots_())
+      AddSlot(batch, slot);
+    batch.Send();
+  }
+
+  void ProcessEntitySlotsData(const std::string& bytes)
+  {
+    auto response = Parse<pb::EntitySlotsData>(bytes, "entity slots data");
+    if (!response)
+      return;
+    Trace("entity slot groups", response->entityslots_size());
+
+    Batch batch(SyncConfig::Type::kSlots);
+    for (const auto& entity : response->entityslots())
+      for (const auto& slot : entity.slots())
+        AddSlot(batch, slot);
+    batch.Send();
+  }
+
+  void ProcessForbiddenTech(const std::string& bytes)
+  {
+    auto response = Parse<pb::ForbiddenTechsResponse>(bytes, "forbidden techs");
+    if (!response)
+      return;
+    Trace("forbidden/chaos techs", response->forbiddentechs_size());
+
+    Batch batch(SyncConfig::Type::kTech);
+    for (const auto& tech : response->forbiddentechs())
+      if (sent.techs.Changed(tech.id(), {tech.tier(), tech.level(), tech.shardcount()}))
+        batch.Add({{"type", SyncConfig::Type::kTech},
+                   {"fid", tech.id()},
+                   {"tier", tech.tier()},
+                   {"level", tech.level()},
+                   {"shard_count", tech.shardcount()}});
+    batch.Send();
+  }
+
+  void ProcessOfficerTraits(const std::string& bytes)
+  {
+    auto response = Parse<pb::OfficerTraitsResponse>(bytes, "active officer traits");
+    if (!response)
+      return;
+    Trace("officers with traits", response->activeofficertraits_size());
+
+    Batch batch(SyncConfig::Type::kTraits);
+    for (const auto& [officer, officer_traits] : response->activeofficertraits())
+      for (const auto& trait : officer_traits.activetraits() | std::views::values)
+        if (sent.traits.Changed({officer, trait.traitid()}, trait.level()))
+          batch.Add({{"type", SyncConfig::Type::kTraits},
+                     {"oid", officer},
+                     {"tid", trait.traitid()},
+                     {"level", trait.level()}});
+    batch.Send();
+  }
+
+  // Store offer prices are in Resource.amount; amountUlong is the fallback.
+  int64_t OfferAmount(const content::Resource& resource)
+  { return static_cast<int64_t>(resource.amount() != 0 ? resource.amount() : resource.amountulong()); }
+
+  // Platform ids are strings; numeric ones go out as numbers, like the rest of the sync data.
+  json OfferId(const std::string& id)
+  {
+    int64_t     value    = 0;
+    const auto* end      = id.data() + id.size();
+    const auto [ptr, ec] = std::from_chars(id.data(), end, value);
+    return !id.empty() && ec == std::errc{} && ptr == end ? json(value) : json(id);
+  }
+
+  // The consumable a bundle sells. Faction store offers are favor levels, sold as consumables.
+  const content::ContentItem* OfferConsumable(const content::BundleContent& bundle)
+  {
+    for (const auto* list : {&bundle.static_(), &bundle.showcase(), &bundle.gifts()})
+      for (const auto& item : list->items())
+        if (item.type() == "consumable")
+          return &item;
+    return nullptr;
+  }
+
+  void AddShip(Batch& batch, int64_t id, int64_t hull_id, const ShipState& state)
+  {
+    if (sent.ships.Changed(id, state))
+      batch.Add({{"type", SyncConfig::Type::kShips},
+                 {"psid", id},
+                 {"level", state.level},
+                 {"level_percentage", state.level_percentage},
+                 {"tier", state.tier},
+                 {"hull_id", hull_id},
+                 {"components", state.components}});
+  }
+
+  void ProcessShips(const std::string& bytes)
+  {
+    auto response = Parse<pb::PlayerShipsResponse>(bytes, "player ships");
+    if (!response)
+      return;
+    Trace("ships", response->ships_size());
+
+    Batch batch(SyncConfig::Type::kShips);
+    for (const auto& ship : response->ships() | std::views::values)
+      AddShip(
+          batch, ship.id(), ship.hullid(),
+          {ship.tier(), ship.level(), ship.levelpercentage(), {ship.components().begin(), ship.components().end()}});
+    batch.Send(&sent.first_ships);
+  }
+
+  // Early in a session resources and starbase modules come in the game's JSON responses rather than as protobuf
+  // entity groups; before client build 267, so did ships and battle headers. Server data can lack any field, so
+  // every read goes through at(), which throws, and a record is read in full before anything is recorded as sent.
+  // A malformed record is skipped, not its section.
+  template <typename Read> void ForEachRecord(const json& section, std::string_view what, Read&& read)
+  {
+    for (const auto& [key, record] : section.items()) {
+      try {
+        read(key, record);
+      } catch (const std::exception& e) {
+        spdlog::error("Skipping malformed {} record {}: {}", what, key, e.what());
+      }
+    }
+  }
+
+  const char* DeployedStateName(pb::DeployedFleetState state)
+  {
+    switch (state) {
+      case pb::DEPLOYEDFLEETSTATE_IDLE:
+        return "Idle";
+      case pb::DEPLOYEDFLEETSTATE_MOVING:
+        return "Moving";
+      case pb::DEPLOYEDFLEETSTATE_WARPING:
+        return "Warping";
+      case pb::DEPLOYEDFLEETSTATE_BATTLING:
+        return "Battling";
+      case pb::DEPLOYEDFLEETSTATE_RECALL:
+        return "Recall";
+      // Docked at a mining node, not the station.
+      case pb::DEPLOYEDFLEETSTATE_DOCKED:
+        return "OnNode";
+      case pb::DEPLOYEDFLEETSTATE_PREBATTLE:
+        return "PreBattle";
+      default:
+        return "Unknown";
+    }
+  }
+
+  // 1234 not 1234.0, and 14.364 not 14.36400032043457.
+  json ShortNumber(float value)
+  {
+    if (std::trunc(value) == value && std::abs(value) < 9.0e15f)
+      return static_cast<int64_t>(value);
+    char   buffer[32];
+    double widened = value;
+    if (const auto [end, ec] = std::to_chars(std::begin(buffer), std::end(buffer), value); ec == std::errc{}) {
+      // Float from_chars needs macOS 26 in Apple's libc++; the JSON parser reads the shortest form back instead.
+      if (auto parsed = json::parse(std::begin(buffer), end, nullptr, false); parsed.is_number())
+        return parsed;
+    }
+    return widened;
+  }
+
+  using StatMap = google::protobuf::Map<int32_t, float>;
+
+  std::optional<float> Stat(const StatMap& stats, pb::ClientModifierType key)
+  {
+    if (const auto it = stats.find(key); it != stats.end())
+      return it->second;
+    return std::nullopt;
+  }
+
+  // Missing stats are left out instead of sent as 0.
+  void PutStat(json& record, const char* name, const StatMap& stats, pb::ClientModifierType key)
+  {
+    if (const auto value = Stat(stats, key); value && std::isfinite(*value))
+      record[name] = ShortNumber(*value);
+  }
+
+  // Summed over the fleet's ships: shipStats has the maximum, shipAttributes the damage taken.
+  void PutPoints(json& record, const char* current_name, const char* max_name, const pb::DeployedFleet& fleet,
+                 pb::ClientModifierType max_key, pb::ClientModifierType damage_key)
+  {
+    double total_max    = 0;
+    double total_damage = 0;
+    bool   found        = false;
+    for (const auto& [ship_id, stats] : fleet.shipstats()) {
+      const auto max = Stat(stats.shipattributes_(), max_key);
+      if (!max)
+        continue;
+      found = true;
+      total_max += *max;
+      if (const auto it = fleet.shipattributes().find(ship_id); it != fleet.shipattributes().end())
+        total_damage += Stat(it->second.shipattributes_(), damage_key).value_or(0.0f);
+    }
+    if (found) {
+      record[current_name] = std::llround(std::max(0.0, total_max - total_damage));
+      record[max_name]     = std::llround(total_max);
+    }
+  }
+
+  // The server's view of the player's deployed fleets. It resends every fleet on each update, so only fleets that
+  // changed are sent; a fleet that left (docked, destroyed) is forgotten so it is sent again when it is back. Each
+  // changed or departed fleet is re-read on the game thread, which fills in some values from this data.
+  void ProcessDeployedFleets(const std::string& bytes)
+  {
+    auto response = Parse<pb::MyDeployedFleetsResponse>(bytes, "deployed fleets");
+    if (!response)
+      return;
+    Trace("deployed fleets", response->fleets_size());
+
+    const int64_t now =
+        std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+    Batch batch(SyncConfig::Type::kFleets);
+    for (const auto& [fleet_id, fleet] : response->fleets()) {
+      json record{{"type", SyncConfig::Type::kFleets},
+                  {"fid", fleet_id},
+                  {"src", "server"},
+                  {"server_state", static_cast<int>(fleet.state())},
+                  {"server_state_name", DeployedStateName(fleet.state())},
+                  {"node_id", fleet.nodeid()}};
+      // Widened through uint32 like the client records.
+      if (fleet.hullids_size() > 0)
+        record["hull_id"] = static_cast<int64_t>(static_cast<uint32_t>(fleet.hullids(0)));
+      if (fleet.has_nodeaddress())
+        record["system_id"] = fleet.nodeaddress().system();
+      PutPoints(record, "hull_hp", "hull_max", fleet, pb::CLIENTMODIFIERTYPE_MODHULLHPMAX,
+                pb::CLIENTMODIFIERTYPE_SHIPHULLDAMAGE);
+      PutPoints(record, "shield_hp", "shield_max", fleet, pb::CLIENTMODIFIERTYPE_MODSHIELDHPMAX,
+                pb::CLIENTMODIFIERTYPE_SHIPSHIELDDAMAGE);
+      PutStat(record, "cargo_cap", fleet.stats(), pb::CLIENTMODIFIERTYPE_MODCARGOCAPACITY);
+      PutStat(record, "warp_range", fleet.stats(), pb::CLIENTMODIFIERTYPE_MODWARPDISTANCE);
+      PutStat(record, "strength", fleet.attributes(), pb::CLIENTMODIFIERTYPE_FLEETSTRENGTH);
+      // A count only, no other players' ids.
+      record["pursued_by"] = fleet.pursuedbynum();
+
+      if (!sent.deployed_fleets.Changed(fleet_id, std::hash<json>{}(record)))
+        continue;
+      record["t"] = now;
+      batch.Add(std::move(record));
+      RereadFleet(fleet_id);
+    }
+    sent.deployed_fleets.Prune(response->fleets(), [](int64_t fleet_id) { RereadFleet(fleet_id); });
+    batch.Send();
+  }
+
+  void ProcessJsonResources(const json& section)
+  {
+    Batch batch(SyncConfig::Type::kResources);
+    ForEachRecord(section, "resource", [&](const std::string& id, const json& resource) {
+      const auto amount = resource.at("current_amount").get<int64_t>();
+      AddResource(batch, sent.resources, "", std::stoll(id), amount);
+    });
+    batch.Send(&sent.first_json_resources);
+  }
+
+  void ProcessJsonModules(const json& section)
+  {
+    Batch batch(SyncConfig::Type::kBuildings);
+    ForEachRecord(section, "starbase module", [&](const std::string&, const json& module) {
+      const auto id    = module.at("id").get<int64_t>();
+      const auto level = module.at("level").get<int32_t>();
+      if (sent.modules.Changed(id, level))
+        batch.Add({{"type", SyncConfig::Type::kBuildings}, {"bid", id}, {"level", level}});
+    });
+    batch.Send();
+  }
+
+  void ProcessJsonShips(const json& section)
+  {
+    Batch batch(SyncConfig::Type::kShips);
+    ForEachRecord(section, "ship", [&](const std::string&, const json& ship) {
+      AddShip(batch, ship.at("id").get<int64_t>(), ship.at("hull_id").get<int64_t>(),
+              {ship.at("tier").get<int32_t>(), ship.at("level").get<int32_t>(),
+               ship.at("level_percentage").get<double>(), ship.at("components").get<std::vector<int64_t>>()});
+    });
+    batch.Send(&sent.first_ships);
+  }
+
+  void ProcessJsonBattles(const json& section)
+  {
+    std::vector<uint64_t> battle_ids;
+    for (const auto& header : section) {
+      const auto id = header.is_object() ? header.find("id") : header.end();
+      if (id == header.end() || !id->is_number_unsigned()) {
+        spdlog::error("Skipping a battle header without a numeric id");
+        continue;
+      }
+      battle_ids.push_back(id->get<uint64_t>());
+    }
+    QueueNewBattles(battle_ids);
+  }
+
+  void ProcessJson(const std::string& bytes)
+  {
+    const auto& options = Config::Get().sync.options;
+    try {
+      const auto result = json::parse(bytes);
+      for (const auto& [key, section] : result.items()) {
+        logging::trace("PROCESS", key, "Processing {} entries (JSON)", section.size());
+        if (key == "battle_result_headers" && options.battlelogs)
+          ProcessJsonBattles(section);
+        else if (key == "resources" && options.resources)
+          ProcessJsonResources(section);
+        else if (key == "starbase_modules" && options.buildings)
+          ProcessJsonModules(section);
+        else if (key == "ships" && options.ships)
+          ProcessJsonShips(section);
+      }
+    } catch (const json::exception& e) {
+      spdlog::error("Error parsing json: {}", e.what());
+    }
+  }
+
+  struct Route {
+    EntityGroup::Kind type;
+    Processor         process;
+    // The category that must be enabled; null for the JSON responses, which check their own sections.
+    bool SyncConfig::* option;
+  };
+
+  const Route kRoutes[] = {
+      {EntityGroup::Kind::AwayAssignmentsList, ProcessAwayAssignments, &SyncConfig::away_assignments},
+      {EntityGroup::Kind::AwayAssignmentsInstance, ProcessAwayAssignment, &SyncConfig::away_assignments},
+      {EntityGroup::Kind::BattleResultHeaders, ProcessBattleHeaders, &SyncConfig::battlelogs},
+      {EntityGroup::Kind::UserProfiles, CachePlayerNames, &SyncConfig::battlelogs},
+      {EntityGroup::Kind::AllianceProfiles, CacheAllianceNames, &SyncConfig::battlelogs},
+      {EntityGroup::Kind::GlobalActiveBuffs, ProcessBuffs, &SyncConfig::buffs},
+      {EntityGroup::Kind::AllianceGetGameProperties, ProcessAllianceGameProperties, &SyncConfig::buffs},
+      {EntityGroup::Kind::StarbaseModules, ProcessStarbaseModules, &SyncConfig::buildings},
+      {EntityGroup::Kind::MyDeployedFleets, ProcessDeployedFleets, &SyncConfig::fleets},
+      {EntityGroup::Kind::PlanetaryBaseData, ProcessHavenBase, &SyncConfig::haven},
+      {EntityGroup::Kind::PlanetaryMapResponse, ProcessHavenMapResponse, &SyncConfig::haven},
+      {EntityGroup::Kind::PlanetaryMapData, ProcessHavenMap, &SyncConfig::haven},
+      {EntityGroup::Kind::PlanetaryMapProsperity, ProcessHavenProsperity, &SyncConfig::haven},
+      {EntityGroup::Kind::PlayerInventories, ProcessInventory, &SyncConfig::inventory},
+      {EntityGroup::Kind::Jobs, ProcessJobs, &SyncConfig::jobs},
+      {EntityGroup::Kind::ActiveMissions, ProcessActiveMissions, &SyncConfig::missions},
+      {EntityGroup::Kind::CompletedMissions, ProcessCompletedMissions, &SyncConfig::missions},
+      {EntityGroup::Kind::Officers, ProcessOfficers, &SyncConfig::officers},
+      {EntityGroup::Kind::ResearchTreesState, ProcessResearch, &SyncConfig::research},
+      {EntityGroup::Kind::Resources, ProcessResources, &SyncConfig::resources},
+      {EntityGroup::Kind::ResourcesDelta, ProcessResourcesDelta, &SyncConfig::resources},
+      {EntityGroup::Kind::AllianceGetBankResources, ProcessAllianceResources, &SyncConfig::resources},
+      {EntityGroup::Kind::ResourcesDeltaAlliance, ProcessAllianceResourcesDelta, &SyncConfig::resources},
+      {EntityGroup::Kind::Ships, ProcessShips, &SyncConfig::ships},
+      {EntityGroup::Kind::EntitySlots, ProcessEntitySlots, &SyncConfig::slots},
+      {EntityGroup::Kind::EntitySlotsData, ProcessEntitySlotsData, &SyncConfig::slots},
+      {EntityGroup::Kind::ForbiddenTechs, ProcessForbiddenTech, &SyncConfig::tech},
+      {EntityGroup::Kind::ActiveOfficerTraits, ProcessOfficerTraits, &SyncConfig::traits},
+      {EntityGroup::Kind::Json, ProcessJson, nullptr},
+  };
+} // namespace
+
+void StartNewSession(const std::string&)
+{ sent = SentData{}; }
+
+UserProfile* LocalUserProfile()
+{
+  auto* manager = UserProfileManager::Instance();
+  return manager ? manager->GetLocalUserProfile() : nullptr;
+}
+
+// Only the record whose user id is `self` is read. The server record carries level 0, so the in-memory Level is used:
+// it lags one own-record response after a level-up.
+void ProcessOwnProfile(const std::string& bytes, const std::string& self, int32_t level)
+{
+  auto response = Parse<pb::UserProfilesResponse>(bytes, "own user profile");
+  if (!response)
+    return;
+  const pb::UserProfile* own = nullptr;
+  for (const auto& profile : response->userprofiles()) {
+    if (profile.userid() == self) {
+      own = &profile;
+      break;
+    }
+  }
+  if (!own)
+    return;
+
+  const auto key = std::make_tuple(level, own->militarymight(), own->planetarybaseunlocked());
+  if (sent.own_profile == key)
+    return;
+  sent.own_profile = key;
+  Batch batch(SyncConfig::Type::kProfile);
+  batch.Add({{"type", SyncConfig::Type::kProfile},
+             {"uid", self},
+             {"level", level},
+             {"xp", own->xp()},
+             {"military_might", own->militarymight()},
+             {"planetary_base_unlocked", own->planetarybaseunlocked()}});
+  batch.Send(&sent.first_profile);
+}
+
+// Realtime slot updates are JSON with ISO timestamps and abbreviated fleet preset keys.
+void ProcessRealtimeSlot(const std::string& bytes)
+{
+  auto data = json::parse(bytes, nullptr, false);
+  if (data.is_discarded()) {
+    spdlog::error("Failed to parse slots JSON");
+    return;
+  }
+  try {
+    const auto timestamp = [](const json& value) {
+      const auto seconds = value.is_string() ? ParseUtcTimestamp(value.get_ref<const std::string&>()) : std::nullopt;
+      return seconds ? json(*seconds) : json(nullptr);
+    };
+
+    const auto& item  = data["slot_item_id"];
+    int64_t     state = item.is_null() ? -1 : item.get<int64_t>();
+    json        params;
+    const auto  type = data["slot_type"].get<int32_t>();
+    switch (type) {
+      case pb::SLOTTYPE_CONSUMABLE:
+        params["expiry_time"] = timestamp(data["consumable_slot_params"]["expiry_time"]);
+        break;
+      case pb::SLOTTYPE_OFFICERPRESET:
+        if (const auto& preset = data["officer_preset_slot_params"]; !preset.is_null()) {
+          params = preset;
+          state  = Hash(params);
+        }
+        break;
+      case pb::SLOTTYPE_FLEETCOMMANDER:
+        if (const auto& commander = data["fleet_commander_slot_params"]; !commander.is_null())
+          params["order"] = commander.at("order");
+        break;
+      case pb::SLOTTYPE_SELECTABLESKILL:
+        if (const auto& skill = data["selectable_skill_slot_params"]; !skill.is_null())
+          params["cooldown_expiration"] = timestamp(skill.value("cooldown_expiration", json()));
+        break;
+      case pb::SLOTTYPE_FORBIDDENTECH:
+        if (const auto& tech = data["forbidden_tech_slot_params"]; !tech.is_null()) {
+          params = tech;
+          state  = Hash(params);
+        }
+        break;
+      case pb::SLOTTYPE_FLEETPRESET:
+        if (const auto& preset = data["fleet_preset_slot_params"]; !preset.is_null()) {
+          auto setups = json::array();
+          for (const auto& setup : preset.at("setups")) {
+            const auto& ship_ids = setup.at("s");
+            setups.push_back({{"drydock_id", setup.at("d")},
+                              {"ship_id", ship_ids.empty() ? json(nullptr) : ship_ids.at(0)},
+                              {"officer_ids", setup.at("o")}});
+          }
+          params = {{"name", preset.at("name")}, {"order", preset.at("order")}, {"setup", setups}};
+          state  = Hash(params);
+        }
+        break;
+      default:
+        return;
+    }
+
+    Batch batch(SyncConfig::Type::kSlots);
+    AddSlot(batch, data["slot_id"].get<int64_t>(), type, data["slot_spec_id"], item, params, state);
+    batch.Send();
+  } catch (const json::exception& e) {
+    spdlog::error("Failed to parse slots JSON: {}", e.what());
+  }
+}
+
+// A store offers group carries whole store categories. The faction store's consumable offers go out as one snapshot,
+// again whenever it changes.
+void ProcessStoreOffers(const std::string& bytes)
+{
+  auto response = Parse<content::Bundles>(bytes, "store offers");
+  if (!response)
+    return;
+  Trace("store offers", response->bundles__size());
+
+  constexpr std::string_view kCategory = "factions";
+  struct Offer {
+    const content::Bundle*      bundle;
+    const content::ContentItem* consumable;
+  };
+  std::vector<Offer> offers;
+  bool               has_category = false;
+  for (const auto& bundle : response->bundles_()) {
+    if (bundle.category() != kCategory)
+      continue;
+    has_category = true;
+    if (const auto* consumable = OfferConsumable(bundle.content()))
+      offers.push_back({&bundle, consumable});
+  }
+  if (!has_category)
+    return;
+  // In a fixed order, so neither the snapshot nor its hash depends on the server's.
+  std::ranges::sort(offers, {}, [](const Offer& offer) {
+    return std::pair{offer.bundle->bundleid(), std::string_view{offer.consumable->id()}};
+  });
+
+  auto records = json::array();
+  for (const auto& [bundle, consumable] : offers) {
+    auto cost = json::array();
+    for (const auto& entry : bundle->cost())
+      for (const auto& resource : entry.cost_())
+        cost.push_back({{"rid", OfferId(resource.id())}, {"amount", OfferAmount(resource)}});
+    // For faction_standing requirements the amount is a zero-based tier index.
+    auto requirements = json::array();
+    for (const auto& resource : bundle->requirements())
+      requirements.push_back(
+          {{"type", resource.type()}, {"id", OfferId(resource.id())}, {"amount", OfferAmount(resource)}});
+    const auto& details = bundle->offerdetails();
+    records.push_back({{"bid", bundle->bundleid()},
+                       {"cid", OfferId(consumable->id())},
+                       {"cost", cost},
+                       {"req", requirements},
+                       {"valid_count", details.validcount()},
+                       {"same_remaining_count", details.sameremainingcount()}});
+  }
+
+  json snapshot = {{"type", SyncConfig::Type::kStoreOffers}, {"category", kCategory}, {"offers", records}};
+  if (snapshot == sent.store_offers)
+    return;
+  sent.store_offers = snapshot;
+  Batch batch(SyncConfig::Type::kStoreOffers);
+  batch.Add(std::move(snapshot));
+  batch.Send();
+}
+
+Processor ProcessorFor(EntityGroup::Kind kind)
+{
+  // Checked per response rather than at install, so targets and categories can change at runtime. Without a wanted
+  // category nothing is copied or parsed.
+  const auto  route   = std::ranges::find(kRoutes, kind, &Route::type);
+  const auto& options = Config::Get().sync.options;
+  if (route == std::end(kRoutes)
+      || !(route->option ? options.*route->option
+                         : options.battlelogs || options.resources || options.buildings || options.ships))
+    return nullptr;
+  return route->process;
+}
+} // namespace data_sync
diff --git a/mods/src/patches/parts/sync/sync.cc b/mods/src/patches/parts/sync/sync.cc
new file mode 100644
index 000000000..05c6b76f8
--- /dev/null
+++ b/mods/src/patches/parts/sync/sync.cc
@@ -0,0 +1,173 @@
+// Data sync: watches the game's server responses and realtime updates and hands them to the processing thread,
+// which turns them into records for the sync targets (records.cc), uploaded by upload.cc. It also captures the game's
+// session for the battle-log requests.
+
+#include "patches/parts/sync/sync.h"
+
+#include "patches/patches.h"
+#include "str_utils.h"
+
+#include "prime/Hub.h"
+#include "prime/server.h"
+
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
+
+#include <functional>
+#include <thread>
+
+namespace data_sync
+{
+namespace
+{
+  // Responses waiting for the processing thread. A login delivers a few dozen at once; 256 leaves room for a
+  // slow backlog without holding unbounded copies of large inventory payloads.
+  constexpr size_t kJobQueueCapacity = 256;
+
+  struct Job {
+    // A plain processor, or one bound to what the game thread knew when the response arrived.
+    std::function<void(const std::string& bytes)> process;
+    std::string                                   bytes;
+  };
+
+  auto& pending = *new BoundedQueue<Job>{"processing", kJobQueueCapacity};
+
+  // One thread processes every response in arrival order, so a delta is never applied before the full state it
+  // updates.
+  void RunJobs()
+  {
+    for (;;) {
+      auto job = pending.Pop();
+      try {
+        job.process(job.bytes);
+      } catch (const std::exception& e) {
+        spdlog::error("Exception while processing sync data: {}", e.what());
+      } catch (...) {
+        spdlog::error("Unknown exception while processing sync data");
+      }
+    }
+  }
+
+  // Runs on the game thread: copies the bytes out and leaves the work to the processing thread.
+  void HandleEntityGroup(EntityGroup* entity_group)
+  {
+    auto* group = entity_group ? entity_group->Group() : nullptr;
+    if (!group || !group->bytes() || group->Length() <= 0)
+      return;
+    const auto type  = entity_group->Type();
+    const auto bytes = [group] {
+      return std::string(reinterpret_cast<const char*>(group->bytes()->data()), static_cast<size_t>(group->Length()));
+    };
+    if (auto process = ProcessorFor(type))
+      pending.Push({process, bytes()});
+
+    // The own profile needs the local player's id and level, which only the game thread can read. Skipped if the
+    // local profile is not ready; a later response retries.
+    if (type == EntityGroup::Kind::UserProfiles && Config::Get().sync.options.profile) {
+      auto* local   = LocalUserProfile();
+      auto* user_id = local ? local->UserId() : nullptr;
+      if (auto self = user_id ? il2cpp::ToUtf8(user_id) : std::string{}; !self.empty())
+        pending.Push({[self = std::move(self), level = local->Level()](const std::string& bytes) {
+                        ProcessOwnProfile(bytes, self, level);
+                      },
+                      bytes()});
+    }
+  }
+
+  // Platform responses (store offers among them) pass through the same registry code as game server responses. Only
+  // store offers are read from them, and only while a target wants them.
+  void HandlePlatformResponse(PlatformServiceResponse* response)
+  {
+    if (auto* groups = response->EntityGroups())
+      for (auto* entity_group : *groups) {
+        auto* group = entity_group && entity_group->Type() == PlatformEntityGroup::Kind::StoreOffers
+                          ? entity_group->Group()
+                          : nullptr;
+        if (group && group->bytes() && group->Length() > 0)
+          pending.Push({ProcessStoreOffers, std::string(reinterpret_cast<const char*>(group->bytes()->data()),
+                                                        static_cast<size_t>(group->Length()))});
+      }
+  }
+
+  void* RtcParser_ParseFinalPayload_Hook(auto original, void* _this, CentrifugoInfo centrifugoInfo,
+                                         RealtimeDataPayload* realtimeDataPayload, void* finalPayload)
+  {
+    if (Config::Get().sync.options.slots && realtimeDataPayload && realtimeDataPayload->Target()
+        && realtimeDataPayload->DataType() && realtimeDataPayload->Data()) {
+      // DataType arrives as a number in a string; JSON is "0". This runs inside the game's parser, so nothing here
+      // may throw.
+      const auto* type = realtimeDataPayload->DataType();
+      if (type->length == 1 && type->chars[0] == u'0')
+        pending.Push({ProcessRealtimeSlot, il2cpp::ToUtf8(realtimeDataPayload->Data())});
+    }
+    return original(_this, centrifugoInfo, realtimeDataPayload, finalPayload);
+  }
+
+  void GameServerModelRegistry_ProcessResultInternal_Hook(auto original, void* _this, void* parsing_context,
+                                                          ServiceResponse* service_response, MethodInfo* method)
+  {
+    // The hooked method is shared generic code; PlatformModelRegistry passes its own response type.
+    if (auto* groups =
+            service_response && service_response->Is<ServiceResponse>() ? service_response->EntityGroups() : nullptr)
+      for (auto* group : *groups)
+        HandleEntityGroup(group);
+    else if (auto* platform = service_response && Config::Get().sync.options.store_offers
+                                  ? service_response->As<PlatformServiceResponse>()
+                                  : nullptr)
+      HandlePlatformResponse(platform);
+    return original(_this, parsing_context, service_response, method);
+  }
+
+  void PrimeApp_InitPrimeServer_Hook(auto original, void* _this, Il2CppString* gameServerUrl,
+                                     Il2CppString* gatewayServerUrl, Il2CppString* sessionId,
+                                     Il2CppString* serverRegion)
+  {
+    original(_this, gameServerUrl, gatewayServerUrl, sessionId, serverRegion);
+    SetGameServer(il2cpp::ToUtf8(gameServerUrl), il2cpp::ToUtf8(sessionId));
+    // A new login (or a switch of account or server) must not be diffed against the last one's data: the new
+    // account gets its first full upload and haven data again, and nothing of the old one is reported gone.
+    pending.Push({StartNewSession, {}});
+  }
+
+  void GameServer_Initialise_Hook(auto original, void* _this, Il2CppString* sessionId, Il2CppString* gameVersion,
+                                  bool encryptRequests, Il2CppString* serverRegion)
+  {
+    original(_this, sessionId, gameVersion, encryptRequests, serverRegion);
+    SetGameVersion(il2cpp::ToUtf8(gameVersion));
+  }
+
+  void GameServer_SetInstanceIdHeader_Hook(auto original, void* _this, int32_t instanceId)
+  {
+    original(_this, instanceId);
+    SetInstanceId(instanceId);
+  }
+
+  void Install()
+  {
+    IL2CPP_HOOK(GameServerModelRegistry::Method("ProcessResultInternal"),
+                GameServerModelRegistry_ProcessResultInternal_Hook);
+    IL2CPP_HOOK(PrimeApp::Class::Method("InitPrimeServer"), PrimeApp_InitPrimeServer_Hook);
+
+    // This hook only captures the game version for the X-PRIME-VERSION header, which has a fallback. It can be
+    // turned off for users whose other mods detour the same method: a native and a managed detour on one prologue
+    // corrupt each other and crash at login.
+    if (!Config::Get().patches.game_version)
+      spdlog::info("Sync: skipping GameServer::Initialise hook (patches.game_version = false)");
+    else
+      IL2CPP_HOOK(GameServer::Method("Initialise"), GameServer_Initialise_Hook);
+
+    IL2CPP_HOOK(GameServer::Method("SetInstanceIdHeader"), GameServer_SetInstanceIdHeader_Hook);
+
+    // Each parser overrides ParseFinalPayload, so these are two distinct native methods.
+    IL2CPP_HOOK(SlotAssignRtcParser::Method("ParseFinalPayload"), RtcParser_ParseFinalPayload_Hook);
+    IL2CPP_HOOK(SlotClearRtcParser::Method("ParseFinalPayload"), RtcParser_ParseFinalPayload_Hook);
+
+    InstallFleetSync();
+
+    StartBattleLogs();
+    std::thread(RunJobs).detach();
+  }
+} // namespace
+} // namespace data_sync
+
+const Feature kSync{"Sync", &Config::Patches::syncpatches, data_sync::Install, data_sync::UpdateFleetSync};
diff --git a/mods/src/patches/parts/sync/sync.h b/mods/src/patches/parts/sync/sync.h
new file mode 100644
index 000000000..aa53feb7f
--- /dev/null
+++ b/mods/src/patches/parts/sync/sync.h
@@ -0,0 +1,158 @@
+#pragma once
+
+// Internal to data sync. Game data is diffed against what was last sent on one processing thread, queued, and
+// uploaded per target on worker threads. Battle logs are fetched from the game server on their own thread,
+// because each needs extra requests to resolve player and alliance names.
+//
+// The threads are detached and run until the process ends, so everything they share is allocated once and never
+// destroyed: static destructors at exit must not free state another thread is still using.
+
+#include "config.h"
+
+#include "prime/server.h"
+
+#include <nlohmann/json.hpp>
+#include <spdlog/spdlog.h>
+
+#include <condition_variable>
+#include <cstdint>
+#include <deque>
+#include <mutex>
+#include <string>
+#include <utility>
+#include <vector>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+template <> struct adl_serializer<SyncConfig::Type> {
+  static void to_json(json& j, const SyncConfig::Type t)
+  {
+    j = nullptr;
+    for (const auto& opt : SyncOptions)
+      if (opt.type == t)
+        j = opt.type_str;
+  }
+};
+NLOHMANN_JSON_NAMESPACE_END
+
+namespace data_sync
+{
+// Sync messages only show up with [sync] logging enabled; debug and trace also need [sync] debug. The message is
+// only formatted when it will be logged.
+namespace logging
+{
+  template <typename... Args>
+  void error(std::string_view type, std::string_view target, fmt::format_string<Args...> format, Args&&... args)
+  {
+    if (Config::Get().sync.logging)
+      spdlog::error("SYNC-{} - {}: {}", type, target, fmt::format(format, std::forward<Args>(args)...));
+  }
+
+  template <typename... Args>
+  void debug(std::string_view type, std::string_view target, fmt::format_string<Args...> format, Args&&... args)
+  {
+    if (Config::Get().sync.logging && Config::Get().sync.debug)
+      spdlog::debug("SYNC-{} - {}: {}", type, target, fmt::format(format, std::forward<Args>(args)...));
+  }
+
+  template <typename... Args>
+  void trace(std::string_view type, std::string_view target, fmt::format_string<Args...> format, Args&&... args)
+  {
+    if (Config::Get().sync.logging && Config::Get().sync.debug)
+      spdlog::trace("SYNC-{} - {}: {}", type, target, fmt::format(format, std::forward<Args>(args)...));
+  }
+} // namespace logging
+
+// A FIFO shared between threads that drops its oldest entry when full. A slow or unreachable target must not
+// grow memory without bound while the game keeps producing updates.
+template <typename T> class BoundedQueue
+{
+public:
+  BoundedQueue(const char* name, size_t capacity)
+      : name_(name)
+      , capacity_(capacity)
+  {
+  }
+
+  void Push(T item)
+  {
+    {
+      std::scoped_lock lock(mutex_);
+      if (items_.size() >= capacity_) {
+        items_.pop_front();
+        // Every 100th drop, so a dead target does not flood the log.
+        if (dropped_++ % 100 == 0)
+          spdlog::warn("[Sync] {} queue is full ({} entries); dropped {} so far", name_, capacity_, dropped_);
+      }
+      items_.push_back(std::move(item));
+    }
+    ready_.notify_one();
+  }
+
+  // Blocks until an item is available.
+  T Pop()
+  {
+    std::unique_lock lock(mutex_);
+    ready_.wait(lock, [this] { return !items_.empty(); });
+    T item = std::move(items_.front());
+    items_.pop_front();
+    return item;
+  }
+
+private:
+  const char*             name_;
+  size_t                  capacity_;
+  size_t                  dropped_ = 0;
+  std::mutex              mutex_;
+  std::condition_variable ready_;
+  std::deque<T>           items_;
+};
+
+// upload.cc
+
+// Queues changed records of one category for every target that wants it. `first_sync` marks the first full
+// upload of a category in this session (sent as X-PRIME-SYNC: 2).
+void Queue(SyncConfig::Type type, const nlohmann::json& records, bool first_sync = false);
+
+// records.cc. Processing thread only.
+
+// Turns one server response into records. Its bytes are an entity group's payload.
+using Processor = void (*)(const std::string& bytes);
+// The processor for an entity group kind, or null when the mod does not sync it or no target wants it.
+Processor ProcessorFor(EntityGroup::Kind kind);
+void      ProcessRealtimeSlot(const std::string& bytes);
+// Platform responses only, so not routed by EntityGroup::Kind.
+void ProcessStoreOffers(const std::string& bytes);
+// The local player's own record from a UserProfiles response. `self` and `level` are read on the game thread when
+// the response arrives, since only the game thread may call into the game.
+void ProcessOwnProfile(const std::string& bytes, const std::string& self, int32_t level);
+// A new login (or a switch of account or server): forgets what was sent, so the new account gets its first full
+// upload and nothing of the old one is reported gone.
+void StartNewSession(const std::string& bytes);
+// The game's record of the local player, or nullptr. Calls into the game.
+UserProfile* LocalUserProfile();
+
+// fleets.cc. Client fleet records are read on the game thread, from fleet_watch and the frame tick.
+
+// Subscribes to fleet_watch when a target wants fleets.
+void InstallFleetSync();
+// Sync's frame work: polls fleet_watch, then re-reads and snapshots what was asked for. Returns at once when fleet
+// sync is off.
+void UpdateFleetSync();
+// Asks the game thread for a full fleet snapshot, sent as a first sync. Any thread.
+void RequestFleetSnapshot();
+// Asks the game thread to re-read a fleet a second from now and resend it if its late values changed. Any thread.
+void RereadFleet(uint64_t fleet_id);
+
+// battlelogs.cc
+
+void StartBattleLogs();
+// Queues the battles that were not sent before. Processing thread only.
+void QueueNewBattles(const std::vector<uint64_t>& battle_ids);
+// Fills the name caches from profile responses the game requested itself.
+void CachePlayerNames(const std::string& bytes);
+void CacheAllianceNames(const std::string& bytes);
+// The game session, captured from the game's own server setup, for the battle-log requests.
+void SetGameServer(std::string url, std::string session_id);
+void SetGameVersion(std::string version);
+void SetInstanceId(int32_t instance_id);
+} // namespace data_sync
diff --git a/mods/src/patches/parts/sync/upload.cc b/mods/src/patches/parts/sync/upload.cc
new file mode 100644
index 000000000..36e852436
--- /dev/null
+++ b/mods/src/patches/parts/sync/upload.cc
@@ -0,0 +1,166 @@
+// Uploads to sync targets: one worker thread, HTTP session and bounded queue per target.
+
+#include "patches/parts/sync/sync.h"
+#include "version.h"
+
+#include <cpr/cpr.h>
+#include <curl/curl.h>
+#include <spdlog/fmt/fmt.h>
+
+#include <map>
+#include <memory>
+#include <thread>
+
+namespace data_sync
+{
+namespace
+{
+  // Each entry is one JSON batch. At the 10 s request timeout a dead target falls behind by a few batches a minute,
+  // so 256 covers a long outage before the oldest go.
+  constexpr size_t kTargetQueueCapacity = 256;
+
+  struct Request {
+    SyncConfig::Type type;
+    std::string      body;
+    bool             first_sync;
+  };
+
+  class Target
+  {
+  public:
+    Target(std::string name, const SyncTargetConfig& config)
+        : name_(std::move(name))
+        , config_(config)
+    {
+      Configure();
+      std::thread(&Target::Run, this).detach();
+    }
+
+    void Push(Request request)
+    { requests_.Push(std::move(request)); }
+
+  private:
+    // A fresh session for config_: one that had a proxy or relaxed TLS keeps them otherwise.
+    void Configure()
+    {
+      const auto& config = config_;
+      http_              = std::make_unique<cpr::Session>();
+      auto& http         = *http_;
+      http.SetUrl(config.url);
+      http.SetUserAgent("stfc community mod " VER_FILE_VERSION_STR " (libcurl/" LIBCURL_VERSION ")");
+      http.SetAcceptEncoding(cpr::AcceptEncoding{});
+      http.SetHttpVersion(cpr::HttpVersion{cpr::HttpVersionCode::VERSION_1_1});
+      http.SetRedirect(cpr::Redirect{3, true, false, cpr::PostRedirectFlags::POST_ALL});
+#ifndef _MODDBG
+      // Debug builds wait indefinitely so a target can be stepped through in a debugger.
+      http.SetConnectTimeout(cpr::ConnectTimeout{3'000});
+      http.SetTimeout(cpr::Timeout{10'000});
+#endif
+      spdlog::debug("sync target '{}': proxy='{}', verify_ssl={}", name_, config.proxy, config.verify_ssl);
+      if (!config.proxy.empty())
+        http.SetProxies({{"http", config.proxy}, {"https", config.proxy}});
+      if (!config.verify_ssl)
+        http.SetSslOptions(
+            cpr::Ssl(cpr::ssl::VerifyHost{false}, cpr::ssl::VerifyPeer{false}, cpr::ssl::NoRevoke{true}));
+      http.SetHeader({
+          {"Content-Type", "application/json"},
+          {"X-Powered-By", "stfc community mod/" VER_FILE_VERSION_STR},
+          {"stfc-sync-token", config.token},
+      });
+    }
+
+    // A settings reload can change the target's address, token or proxy; the session follows before the next
+    // upload. A target removed from the settings is no longer given uploads.
+    void FollowSettings()
+    {
+      const auto& targets = Config::Get().sync.targets;
+      const auto  it      = targets.find(name_);
+      if (it == targets.end())
+        return;
+      const auto& now = it->second;
+      if (now.url == config_.url && now.token == config_.token && now.proxy == config_.proxy
+          && now.verify_ssl == config_.verify_ssl)
+        return;
+      config_ = now;
+      Configure();
+    }
+
+    void Run()
+    {
+      for (;;) {
+        auto request = requests_.Pop();
+        FollowSettings();
+        const auto label = fmt::format("{} ({})", name_, to_string(request.type));
+        try {
+          Send(label, std::move(request));
+        } catch (const std::exception& error) {
+          spdlog::error("Failed to send {} sync data: {}", label, error.what());
+        } catch (...) {
+          spdlog::error("Failed to send {} sync data: unknown error", label);
+        }
+      }
+    }
+
+    void Send(const std::string& label, Request request)
+    {
+      auto& headers = http_->GetHeader();
+      if (request.first_sync) {
+        headers.insert_or_assign("X-PRIME-SYNC", "2");
+        logging::trace("UPLOAD", label, "Adding X-Prime-Sync header for initial sync");
+      } else {
+        headers.erase("X-PRIME-SYNC");
+      }
+      http_->SetBody(cpr::Body{std::move(request.body)});
+      logging::debug("UPLOAD", label, "Sending data to {}", http_->GetFullRequestUrl());
+
+      const auto response = http_->Post();
+      const auto elapsed  = response.elapsed * 1'000;
+      if (response.status_code == 0)
+        logging::error("UPLOAD", label, "Failed to send request: {}", response.error.message);
+      else if (response.status_code == 501)
+        logging::error("UPLOAD", label,
+                       "Sync target does not support this operation ({}, after {:.0f} ms). Consider turning off this "
+                       "upload category for the target.",
+                       response.status_line, elapsed);
+      else if (response.status_code >= 400)
+        logging::error("UPLOAD", label, "Failed to communicate with server: {} (after {:.0f} ms)", response.status_line,
+                       elapsed);
+      else
+        logging::debug("UPLOAD", label, "Response: {} ({:.0f} ms elapsed)", response.status_line, elapsed);
+    }
+
+    std::string                   name_;
+    SyncTargetConfig              config_;
+    std::unique_ptr<cpr::Session> http_;
+    BoundedQueue<Request>         requests_{"target", kTargetQueueCapacity};
+  };
+
+  // Started on first use, so a target added to the settings later still gets a worker. Never destroyed, see sync.h.
+  Target& TargetFor(const std::string& name, const SyncTargetConfig& config)
+  {
+    static auto&     targets = *new std::map<std::string, Target*, std::less<>>;
+    static auto&     mutex   = *new std::mutex;
+    std::scoped_lock lock(mutex);
+    auto&            target = targets[name];
+    if (!target)
+      target = new Target(name, config);
+    return *target;
+  }
+} // namespace
+
+void Queue(SyncConfig::Type type, const nlohmann::json& records, bool first_sync)
+{
+  // Another category's first sync: the targets get a full fleet snapshot with it.
+  if (first_sync && type != SyncConfig::Type::kFleets)
+    RequestFleetSnapshot();
+  std::string body;
+  for (const auto& [name, config] : Config::Get().sync.targets) {
+    if (!config.enabled(type))
+      continue;
+    if (body.empty())
+      body = records.dump();
+    TargetFor(name, config).Push({type, body, first_sync});
+  }
+  logging::debug("QUEUE", to_string(type), "Added {} entries to sync queue", records.size());
+}
+} // namespace data_sync
diff --git a/mods/src/patches/parts/testing.cc b/mods/src/patches/parts/testing.cc
deleted file mode 100644
index eb1e78092..000000000
--- a/mods/src/patches/parts/testing.cc
+++ /dev/null
@@ -1,117 +0,0 @@
-#include "config.h"
-
-#include "prime/ActionQueueManager.h"
-#include "prime/ActionRequirement.h"
-#include "prime/BlurController.h"
-#include "prime/BookmarksManager.h"
-#include "prime/ChatManager.h"
-#include "prime/ChatMessageListLocalViewController.h"
-#include "prime/ClientModifierType.h"
-#include "prime/DeploymentManager.h"
-#include "prime/FleetLocalViewController.h"
-#include "prime/FleetsManager.h"
-#include "prime/FullScreenChatViewController.h"
-#include "prime/Hub.h"
-#include "prime/InventoryForPopup.h"
-#include "prime/KeyCode.h"
-#include "prime/NavigationSectionManager.h"
-#include "prime/ScanTargetViewController.h"
-#include "prime/SceneManager.h"
-#include "prime/ScreenManager.h"
-#include <prime/UIBehaviour.h>
-
-#include <il2cpp/il2cpp.h>
-#include <spud/detour.h>
-#include <spud/signature.h>
-
-struct AppConfig : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Core", "AppConfig">;
-
-  Il2CppString* PlatformSettingsUrl()
-  { return Get<"PlatformSettingsUrl", Il2CppString*>(); }
-  void SetPlatformSettingsUrl(Il2CppString* value)
-  { Set<"PlatformSettingsUrl">(value); }
-  Il2CppString* PlatformApiKey()
-  { return Get<"PlatformApiKey", Il2CppString*>(); }
-  void SetPlatformApiKey(Il2CppString* value)
-  { Set<"PlatformApiKey">(value); }
-  Il2CppString* AssetUrlOverride()
-  { return Get<"AssetUrlOverride", Il2CppString*>(); }
-  void SetAssetUrlOverride(Il2CppString* value)
-  { Set<"AssetUrlOverride">(value); }
-};
-
-struct Model : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Core", "Model">;
-
-  AppConfig* appConfig()
-  { return Field<"_appConfig", AppConfig*>(); }
-};
-
-void Cursor_SetCursor(auto original, void* _this, ptrdiff_t texture, Vector2* hotspot, int cursorMode)
-{
-#if _WIN32
-  if (!Config::Get().allow_cursor) {
-    SetCursor(LoadCursor(NULL, IDC_ARROW));
-    ClipCursor(nullptr); // free cursor from any Unity clipping
-    return;
-  }
-#endif
-
-  return original(_this, texture, hotspot, cursorMode);
-}
-
-void Model_LoadConfigs(auto original, Model* _this)
-{
-  original(_this);
-  auto config = _this->appConfig();
-  if (!config) {
-    return;
-  }
-
-  if (!Config::Get().config_settings_url.empty()) {
-    config->SetPlatformSettingsUrl(il2cpp_string_new(Config::Get().config_settings_url.c_str()));
-  }
-
-  if (!Config::Get().config_assets_url_override.empty()) {
-    config->SetAssetUrlOverride(il2cpp_string_new(Config::Get().config_assets_url_override.c_str()));
-  }
-}
-
-void SetActive_hook(auto original, void* _this, bool active)
-{
-  static auto IsActiveSelf = il2cpp::ResolveICall<bool(void*)>("UnityEngine.GameObject::get_activeSelf()");
-
-  if (active && IsActiveSelf(_this)) {
-    return;
-    // __debugbreak();
-  }
-  return original(_this, active);
-}
-
-bool IsQueueEnabled(auto original, void* _this)
-{
-  if (Config::Get().queue_enabled) {
-    return original(_this);
-  }
-
-  return false;
-}
-
-void InstallTestPatches()
-{
-  using Cursor = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Cursor">;
-  if (auto m = Cursor::Method("SetCursor_Injected"))
-    SPUD_STATIC_DETOUR(m.Pointer(), Cursor_SetCursor);
-
-  if (auto m = Model::Class::Method("LoadConfigs", 0))
-    SPUD_STATIC_DETOUR(m.Pointer(), Model_LoadConfigs);
-
-  // this method is not accessible in v48084
-  //   static auto SetActive = il2cpp::ResolveICall<void(void*, bool)>("UnityEngine.GameObject::SetActive(System.Boolean)");
-  //   if (SetActive)
-  //     SPUD_STATIC_DETOUR(SetActive, SetActive_hook);
-
-  if (auto m = ActionQueueManager::Class::Method("IsQueueUnlocked"))
-    SPUD_STATIC_DETOUR(m.Pointer(), IsQueueEnabled);
-}
diff --git a/mods/src/patches/parts/thin_queue_protection.cc b/mods/src/patches/parts/thin_queue_protection.cc
index 3c6860b4f..705cd356a 100644
--- a/mods/src/patches/parts/thin_queue_protection.cc
+++ b/mods/src/patches/parts/thin_queue_protection.cc
@@ -1,114 +1,30 @@
 #include "patches/action_queue_guard_policy.h"
+#include "patches/patches.h"
 #include <config.h>
 
 // Port of the active v2.1.0-guffa.10 guard, not the dormant completion repair.
 // Shared 64-bit managed layout; incompatible runtime contracts leave the feature unavailable.
+#include "prime/queues.h"
 #include <algorithm>
-#include <atomic>
 #include <array>
-#include <utility>
+#include <atomic>
 #include <cstring>
-#include <il2cpp/il2cpp_helper.h>
-#include <il2cpp/method_contract.h>
+#include <il2cpp/hook.h>
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
+#include <utility>
+
+using namespace queue_bindings::thin;
 
 namespace
 {
 using Object = Il2CppObject;
 using action_queue_guard::QueueState;
 std::atomic_bool ready{false};
-Il2CppClass *    queueClass{}, *actionClass{}, *playerClass{}, *deployedClass{};
+
 using Id = std::int64_t;
-Id (*playerId)(Object*);
-Id (*deployedId)(Object*);
-int (*playerState)(Object*);
-int (*deployedState)(Object*);
-int (*removalReason)(Object*);
-bool (*destroyed)(Object*);
-bool (*battling)(Object*);
-int (*tryEngage)(Object*, Object*, Object*);
-void (*processTarget)(Object*, Id, bool);
 
 bool Enabled()
-{ return ready.load() && Config::Get().kirshara_fixes && Config::Get().queue_enabled; }
-
-bool Is(Object* object, Il2CppClass* cls)
-{ return object && il2cpp_object_get_class(object) == cls; }
-
-template <typename T> T Read(const void* object, std::size_t offset)
-{
-  T value{};
-  if (object)
-    std::memcpy(&value, static_cast<const char*>(object) + offset, sizeof(value));
-  return value;
-}
-
-// Inspect storage without invoking List getters/enumerators. Unknown layouts fail closed.
-Il2CppArraySize* List(Object* list, Il2CppClass* element, int limit, int& count)
-{
-  count = -1;
-  if (!list)
-    return nullptr;
-  auto* cls     = il2cpp_object_get_class(list);
-  auto* size    = il2cpp_class_get_field_from_name(cls, "_size");
-  auto* storage = il2cpp_class_get_field_from_name(cls, "_items");
-  if (!size || !storage || !size->type || size->type->type != IL2CPP_TYPE_I4 || !storage->type
-      || storage->type->type != IL2CPP_TYPE_SZARRAY || size->type->byref || storage->type->byref
-      || (il2cpp_field_get_flags(size) & FIELD_ATTRIBUTE_STATIC)
-      || (il2cpp_field_get_flags(storage) & FIELD_ATTRIBUTE_STATIC))
-    return nullptr;
-  Il2CppArray* items{};
-  il2cpp_field_get_value(list, size, &count);
-  il2cpp_field_get_value(list, storage, &items);
-  if (count < 0 || count > limit || !items || il2cpp_array_length(items) < static_cast<unsigned>(count)
-      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Object*>(items))) != element)
-    return nullptr;
-  return reinterpret_cast<Il2CppArraySize*>(items);
-}
-
-QueueState Snapshot(Object* queue)
-{
-  QueueState s;
-  if (!Is(queue, queueClass))
-    return s;
-  auto* items = List(Read<Object*>(queue, 0x28), actionClass, 128, s.count);
-  if (!items)
-    return {};
-  s.player_fleet_id        = Read<Id>(queue, 0x30);
-  s.is_engaging            = Read<bool>(queue, 0x10);
-  s.last_engaged_target_id = Read<Id>(queue, 0x18);
-  s.pending_target_id      = Read<Id>(queue, 0x20);
-  s.captured_target_count  = std::min(s.count, static_cast<int>(s.target_ids.size()));
-  s.targets_truncated      = s.count > s.captured_target_count;
-  for (int i = 0; i < s.captured_target_count; ++i) {
-    auto* action = static_cast<Object*>(items->vector[i]);
-    if (!Is(action, actionClass))
-      return {};
-    s.target_ids[i] = Read<Id>(action, 0x10);
-    if (!s.target_ids[i])
-      return {};
-  }
-  s.head_target_id = s.count ? s.target_ids[0] : 0;
-  s.present        = s.player_fleet_id != 0;
-  return s;
-}
-
-Object* FindQueue(Object* manager, Id fleet, Id head = 0)
-{
-  auto* array = Read<Il2CppArray*>(manager, 0x48);
-  if (!array || il2cpp_array_length(array) > 64
-      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Object*>(array))) != queueClass)
-    return nullptr;
-  auto* items = reinterpret_cast<Il2CppArraySize*>(array);
-  for (unsigned i = 0; i < items->max_length; ++i) {
-    auto*      queue = static_cast<Object*>(items->vector[i]);
-    const auto s     = Snapshot(queue);
-    if (s.present && (head ? s.head_target_id == head : s.player_fleet_id == fleet))
-      return queue;
-  }
-  return nullptr;
-}
+{ return ready.load() && Config::Get().control.kirshara_fixes && Config::Get().control.queue_enabled; }
 
 bool Resume(Object* manager, Object* queue, Object* player, bool idle, const QueueState& before,
             const QueueState& after, const char* source)
@@ -126,7 +42,7 @@ bool Resume(Object* manager, Object* queue, Object* player, bool idle, const Que
   return result == action_queue_guard::kEngageResultSuccess;
 }
 
-bool Plan(auto original, Object* manager, Object* player)
+bool ActionQueueManager_DoPlanPathAndEngageTarget_Hook(auto original, Object* manager, Object* player)
 {
   if (!Enabled() || !Is(player, playerClass))
     return original(manager, player);
@@ -142,7 +58,8 @@ bool Plan(auto original, Object* manager, Object* player)
   return Resume(manager, queue, player, idle, before, after, "planner") || result;
 }
 
-void Stall(auto original, Object* manager, Object* queue, Object* player, Object* deployed)
+void ActionQueueManager_HandleStall_Hook(auto original, Object* manager, Object* queue, Object* player,
+                                         Object* deployed)
 {
   if (!Enabled() || !Is(player, playerClass) || !Is(deployed, deployedClass)) {
     original(manager, queue, player, deployed);
@@ -159,7 +76,7 @@ void Stall(auto original, Object* manager, Object* queue, Object* player, Object
   Resume(manager, queue, player, idle, before, after, "watchdog");
 }
 
-void Disposed(auto original, Object* manager, Object* fleets)
+void ActionQueueManager_OnFleetsDisposedEventHandler_Hook(auto original, Object* manager, Object* fleets)
 {
   std::array<Id, 64> targets{};
   unsigned           captured{};
@@ -194,125 +111,31 @@ void Disposed(auto original, Object* manager, Object* fleets)
   }
 }
 
-bool Field(Il2CppClass* cls, const char* name, std::ptrdiff_t offset, Il2CppTypeEnum type)
-{
-  auto* f = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
-  const bool valid = f && f->offset == offset && f->type && !f->type->byref
-                     && !(il2cpp_field_get_flags(f) & FIELD_ATTRIBUTE_STATIC) && f->type->type == type;
-  if (!valid)
-    spdlog::warn("[ThinQueueProtection] {}.{}: expected instance field offset=0x{:X} type={}; "
-                   "actual offset={} type={} static={} byref={}",
-                   cls ? cls->name : "<missing class>", name, offset, static_cast<int>(type),
-                   f ? f->offset : -1, f && f->type ? static_cast<int>(f->type->type) : -1,
-                   f && f->type && bool(il2cpp_field_get_flags(f) & FIELD_ATTRIBUTE_STATIC),
-                   f && f->type && bool(f->type->byref));
-  return valid;
-}
-
-template <typename T> bool Getter(T& out, Il2CppClass* cls, const char* name, const char* result)
-{
-  const auto* method = method_contract::Resolve(cls, name, false, result, {});
-  out                = method && !method->has_full_generic_sharing_signature
-                           ? reinterpret_cast<T>(method_contract::Pointer(method)) : nullptr;
-  if (method && method->return_type->type == IL2CPP_TYPE_VALUETYPE) {
-    auto*       type       = il2cpp_class_from_type(method->return_type);
-    const auto* underlying = type && il2cpp_class_is_enum(type) ? il2cpp_class_enum_basetype(type) : nullptr;
-    if (!underlying || underlying->type != IL2CPP_TYPE_I4)
-      out = nullptr;
-  }
-  if (!out)
-    spdlog::warn("[ThinQueueProtection] {}.{}: expected instance {}(); {}", cls ? cls->name : "<missing class>",
-                   name, result, !method ? "method unavailable"
-                                 : method->has_full_generic_sharing_signature ? "unsupported generic sharing"
-                                 : !method->methodPointer ? "native pointer unavailable" : "expected Int32 enum result");
-  return out != nullptr;
-}
 } // namespace
 
+namespace
+{
 void InstallThinQueueProtection()
 {
-  auto* manager = il2cpp_get_class_helper("Assembly-CSharp", "Prime.ActionQueue", "ActionQueueManager").get_cls();
-  queueClass    = il2cpp_get_class_helper("Assembly-CSharp", "Prime.ActionQueue", "ActionQueueInstance").get_cls();
-  actionClass   = il2cpp_get_class_helper("Assembly-CSharp", "Prime.ActionQueue", "QueueableAction").get_cls();
-  playerClass   = il2cpp_get_class_helper("Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetPlayerData").get_cls();
-  deployedClass = il2cpp_get_class_helper("Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetDeployedData").get_cls();
-  using method_contract::Pointer;
-  using method_contract::Resolve;
-  const auto* plan_info = Resolve(manager, "DoPlanPathAndEngageTarget", false, "System.Boolean",
-                                   {"Digit.PrimeServer.Models.FleetPlayerData"});
-  auto* plan = Pointer(plan_info);
-  const auto* stall_info = Resolve(manager, "HandleStall", false, "System.Void",
-                                   {"Prime.ActionQueue.ActionQueueInstance", "Digit.PrimeServer.Models.FleetPlayerData",
-                                    "Digit.PrimeServer.Models.FleetDeployedData"});
-  auto* stall = Pointer(stall_info);
-  const auto* disposed_info = Resolve(manager, "OnFleetsDisposedEventHandler", false, "System.Void",
-                                   {"System.Collections.Generic.List<Digit.PrimeServer.Models.FleetDeployedData>"});
-  auto* disposed = Pointer(disposed_info);
-  const auto* engage = Resolve(manager, "TryPlanPathAndEngageTarget", false, "Digit.Prime.Combat.EngageResult",
-                               {"Digit.PrimeServer.Models.FleetPlayerData", "Prime.ActionQueue.ActionQueueInstance"});
-  tryEngage          = reinterpret_cast<decltype(tryEngage)>(Pointer(engage));
-  const auto* process_info = Resolve(manager, "ProcessQueue", false, "System.Void", {"System.Int64", "System.Boolean"});
-  processTarget = reinterpret_cast<decltype(processTarget)>(Pointer(process_info));
-  auto*       result     = engage ? il2cpp_class_from_type(engage->return_type) : nullptr;
-  const auto* underlying = result && il2cpp_class_is_enum(result) ? il2cpp_class_enum_basetype(result) : nullptr;
-  const bool  valid =
-      manager && queueClass && actionClass && playerClass && deployedClass && plan && stall && disposed && tryEngage
-      && processTarget && underlying && underlying->type == IL2CPP_TYPE_I4
-      && !plan_info->has_full_generic_sharing_signature && !stall_info->has_full_generic_sharing_signature
-      && !disposed_info->has_full_generic_sharing_signature && !engage->has_full_generic_sharing_signature
-      && !process_info->has_full_generic_sharing_signature
-      && plan != stall && plan != disposed && stall != disposed
-      && Field(manager, "_battleQueue", 0x48, IL2CPP_TYPE_SZARRAY)
-      && Field(queueClass, "IsEngaging", 0x10, IL2CPP_TYPE_BOOLEAN)
-      && Field(queueClass, "LastEngagedTargetId", 0x18, IL2CPP_TYPE_I8)
-      && Field(queueClass, "PendingEngageTargetId", 0x20, IL2CPP_TYPE_I8)
-      && Field(queueClass, "_actionQueue", 0x28, IL2CPP_TYPE_GENERICINST)
-      && Field(queueClass, "<PlayerFleetId>k__BackingField", 0x30, IL2CPP_TYPE_I8)
-      && Field(actionClass, "<FleetId>k__BackingField", 0x10, IL2CPP_TYPE_I8)
-      && Getter(playerId, playerClass, "get_Id", "System.Int64")
-      && Getter(playerState, playerClass, "get_CurrentState", "Digit.PrimeServer.Models.FleetState")
-      && Getter(deployedId, deployedClass, "get_ID", "System.Int64")
-      && Getter(deployedState, deployedClass, "get_CurrentState", "Digit.PrimeServer.Models.DeployedFleetState")
-      && Getter(removalReason, deployedClass, "get_RemovalReason", "Digit.PrimeServer.Models.FleetRemovalReason")
-      && Getter(destroyed, deployedClass, "get_IsDestroyed", "System.Boolean")
-      && Getter(battling, deployedClass, "get_CurrentlyBattling", "System.Boolean");
-  if (!valid) {
-    for (const auto& [type, name] : std::array{
-             std::pair{manager, "Prime.ActionQueue.ActionQueueManager"},
-             std::pair{queueClass, "Prime.ActionQueue.ActionQueueInstance"},
-             std::pair{actionClass, "Prime.ActionQueue.QueueableAction"},
-             std::pair{playerClass, "Digit.PrimeServer.Models.FleetPlayerData"},
-             std::pair{deployedClass, "Digit.PrimeServer.Models.FleetDeployedData"}})
-      if (!type) spdlog::warn("[ThinQueueProtection] unavailable: missing class {}", name);
-    const std::array methods{
-        std::pair{plan_info, "ActionQueueManager.DoPlanPathAndEngageTarget(FleetPlayerData) -> Boolean"},
-        std::pair{stall_info, "ActionQueueManager.HandleStall(ActionQueueInstance, FleetPlayerData, FleetDeployedData) -> Void"},
-        std::pair{disposed_info, "ActionQueueManager.OnFleetsDisposedEventHandler(List<FleetDeployedData>) -> Void"},
-        std::pair{engage, "ActionQueueManager.TryPlanPathAndEngageTarget(FleetPlayerData, ActionQueueInstance) -> EngageResult"},
-        std::pair{process_info, "ActionQueueManager.ProcessQueue(Int64, Boolean) -> Void"}};
-    for (const auto& [method, name] : methods)
-      if (!method || !method->methodPointer || method->has_full_generic_sharing_signature)
-        spdlog::warn("[ThinQueueProtection] unavailable: {}: {}", name,
-                       method && method->has_full_generic_sharing_signature ? "unsupported generic sharing"
-                                                                           : "instance method unavailable");
-    if (!underlying || underlying->type != IL2CPP_TYPE_I4)
-      spdlog::warn("[ThinQueueProtection] unavailable: EngageResult must be an Int32 enum");
-    // Only these three methods are detoured; the other two are native calls.
-    for (size_t i = 0; i < 3; ++i)
-      for (size_t j = 0; j < i; ++j)
-        if (methods[i].first && methods[j].first && methods[i].first->methodPointer
-            && methods[i].first->methodPointer == methods[j].first->methodPointer)
-          spdlog::warn("[ThinQueueProtection] unavailable: {} and {} share a native hook target",
-                         methods[i].second, methods[j].second);
+  if (!ResolveBindings())
     return;
-  }
-  const bool a = SPUD_STATIC_DETOUR(plan, Plan) != nullptr;
-  const bool b = SPUD_STATIC_DETOUR(stall, Stall) != nullptr;
-  const bool c = SPUD_STATIC_DETOUR(disposed, Disposed) != nullptr;
-  for (const auto& [installed, name] : std::array{
-           std::pair{a, "ActionQueueManager.DoPlanPathAndEngageTarget"},
-           std::pair{b, "ActionQueueManager.HandleStall"}, std::pair{c, "ActionQueueManager.OnFleetsDisposedEventHandler"}})
-    if (!installed) spdlog::warn("[ThinQueueProtection] hook installation failed: {}; feature unavailable", name);
+  const bool a = IL2CPP_DETOUR(plan, ActionQueueManager_DoPlanPathAndEngageTarget_Hook,
+                               "ActionQueueManager_DoPlanPathAndEngageTarget_Hook")
+                 != nullptr;
+  const bool b =
+      IL2CPP_DETOUR(stall, ActionQueueManager_HandleStall_Hook, "ActionQueueManager_HandleStall_Hook") != nullptr;
+  const bool c = IL2CPP_DETOUR(disposed, ActionQueueManager_OnFleetsDisposedEventHandler_Hook,
+                               "ActionQueueManager_OnFleetsDisposedEventHandler_Hook")
+                 != nullptr;
+  for (const auto& [installed, name] : std::array{std::pair{a, "ActionQueueManager.DoPlanPathAndEngageTarget"},
+                                                  std::pair{b, "ActionQueueManager.HandleStall"},
+                                                  std::pair{c, "ActionQueueManager.OnFleetsDisposedEventHandler"}})
+    if (!installed)
+      spdlog::warn("[ThinQueueProtection] hook installation failed: {}; feature unavailable", name);
   ready.store(a && b && c);
   spdlog::info("[ThinQueueProtection] ready={}", ready.load());
 }
+} // namespace
+
+const Feature kThinQueueProtection{"ThinQueueProtection", &Config::Patches::thinqueueprotectionhooks,
+                                   InstallThinQueueProtection};
diff --git a/mods/src/patches/parts/toast_text.h b/mods/src/patches/parts/toast_text.h
new file mode 100644
index 000000000..89cd88487
--- /dev/null
+++ b/mods/src/patches/parts/toast_text.h
@@ -0,0 +1,94 @@
+#pragma once
+
+// Text handling for toast notifications that does not touch the game, kept apart so it can be tested.
+
+#include <algorithm>
+#include <span>
+#include <string>
+#include <string_view>
+
+namespace toast_text
+{
+// Replaces {N} with values[N]. The zero-padded form {N:000} pads the value to that width; other formats are
+// filled without padding. Placeholders whose value is empty are left as they are.
+inline std::string FormatPlaceholders(std::string text, std::span<const std::string> values)
+{
+  for (size_t i = 0; i < values.size(); ++i) {
+    const auto& value = values[i];
+    if (value.empty())
+      continue;
+    const auto prefix = "{" + std::to_string(i);
+    for (auto pos = text.find(prefix); pos != std::string::npos; pos = text.find(prefix, pos)) {
+      const auto after = pos + prefix.size();
+      const auto end   = text.find('}', after);
+      if (end == std::string::npos)
+        break;
+      auto replacement = value;
+      if (after != end) {
+        // "{1" also starts "{10}"; only "{1}" and "{1:...}" are this placeholder.
+        if (text[after] != ':') {
+          pos = after;
+          continue;
+        }
+        const auto format = std::string_view(text).substr(after + 1, end - after - 1);
+        if (!format.empty() && format.find_first_not_of('0') == std::string_view::npos
+            && replacement.size() < format.size())
+          replacement.insert(0, format.size() - replacement.size(), '0');
+      }
+      text.replace(pos, end - pos + 1, replacement);
+      pos += replacement.size();
+    }
+  }
+  return text;
+}
+
+inline size_t CountPlaceholders(std::string_view text)
+{ return static_cast<size_t>(std::ranges::count(text, '{')); }
+
+// Removes Unity rich text tags such as <color=#FF0000>, <b> and </size>.
+inline std::string StripRichText(std::string_view text)
+{
+  std::string result;
+  result.reserve(text.size());
+  for (size_t i = 0; i < text.size();) {
+    if (text[i] == '<') {
+      if (const auto end = text.find('>', i); end != std::string_view::npos) {
+        i = end + 1;
+        continue;
+      }
+    }
+    result += text[i++];
+  }
+  return result;
+}
+
+// Upper-cases the first letter of each word and lower-cases the rest. Words split on space, '-' and '_'.
+inline std::string TitleCase(std::string text)
+{
+  bool word_start = true;
+  for (auto& c : text) {
+    if (word_start && c >= 'a' && c <= 'z')
+      c = static_cast<char>(c - 'a' + 'A');
+    else if (!word_start && c >= 'A' && c <= 'Z')
+      c = static_cast<char>(c - 'A' + 'a');
+    word_start = c == ' ' || c == '-' || c == '_';
+  }
+  return text;
+}
+
+// A readable name from a hull's internal key, for hulls the game cannot localize:
+// "Hull_L30_Destroyer_Klingon_LIVE" -> "Lv.30 Destroyer Klingon".
+inline std::string HullKeyName(std::string_view key)
+{
+  if (key.size() > 5 && key.ends_with("_LIVE"))
+    key.remove_suffix(5);
+  if (key.starts_with("Hull_"))
+    key.remove_prefix(5);
+
+  std::string name(key);
+  std::ranges::replace(name, '_', ' ');
+  if (name.size() >= 2 && name[0] == 'L' && name[1] >= '0' && name[1] <= '9')
+    name = "Lv." + name.substr(1);
+  return TitleCase(std::move(name));
+}
+} // namespace toast_text
diff --git a/mods/src/patches/parts/toasts.cc b/mods/src/patches/parts/toasts.cc
new file mode 100644
index 000000000..2ee11bbb8
--- /dev/null
+++ b/mods/src/patches/parts/toasts.cc
@@ -0,0 +1,423 @@
+// Toast banners: hides the types listed in disabled_banner_types and mirrors the ones in notify_banner_types to
+// Windows notifications, with a readable body for battle results.
+
+#include "config.h"
+#include "patches/patches.h"
+#include "patches/parts/toast_text.h"
+#include "str_utils.h"
+
+#include "prime/fleet.h"
+#include "prime/server.h"
+#include "prime/ui.h"
+
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/spdlog.h>
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#if _WIN32
+#include <windows.h>
+#include <winrt/windows.data.xml.dom.h>
+#include <winrt/windows.ui.notifications.h>
+#endif
+
+namespace
+{
+using toast_text::FormatPlaceholders;
+
+constexpr std::pair<ToastState, const char*> kTitles[] = {
+    {ToastState::Standard, "Notification"},
+    {ToastState::FactionWarning, "Faction Warning"},
+    {ToastState::FactionLevelUp, "Faction Level Up"},
+    {ToastState::FactionLevelDown, "Faction Level Down"},
+    {ToastState::FactionDiscovered, "Faction Discovered"},
+    {ToastState::IncomingAttack, "Incoming Attack!"},
+    {ToastState::IncomingAttackFaction, "Incoming Faction Attack!"},
+    {ToastState::FleetBattle, "Fleet Battle"},
+    {ToastState::StationBattle, "Station Under Attack!"},
+    {ToastState::StationVictory, "Station Victory!"},
+    {ToastState::Victory, "Victory!"},
+    {ToastState::Defeat, "Defeat"},
+    {ToastState::StationDefeat, "Station Defeat"},
+    {ToastState::Tournament, "Event Progress"},
+    {ToastState::ArmadaCreated, "Armada Created"},
+    {ToastState::ArmadaCanceled, "Armada Canceled"},
+    {ToastState::ArmadaIncomingAttack, "Armada Under Attack!"},
+    {ToastState::ArmadaBattleWon, "Armada Victory!"},
+    {ToastState::ArmadaBattleLost, "Armada Defeated"},
+    {ToastState::DiplomacyUpdated, "Diplomacy Updated"},
+    {ToastState::JoinedTakeover, "Territory Capture Joined"},
+    {ToastState::CompetitorJoinedTakeover, "Competitor Joined Territory"},
+    {ToastState::AbandonedTerritory, "Territory Abandoned"},
+    {ToastState::TakeoverVictory, "Takeover Victory!"},
+    {ToastState::TakeoverDefeat, "Takeover Defeat"},
+    {ToastState::TreasuryProgress, "Treasury Progress"},
+    {ToastState::TreasuryFull, "Treasury Full"},
+    {ToastState::Achievement, "Achievement"},
+    {ToastState::AssaultVictory, "Assault Victory!"},
+    {ToastState::AssaultDefeat, "Assault Defeat"},
+    {ToastState::ChallengeComplete, "Challenge Complete"},
+    {ToastState::ChallengeFailed, "Challenge Failed"},
+    {ToastState::StrikeHit, "Strike Hit"},
+    {ToastState::StrikeDefeat, "Strike Defeat"},
+    {ToastState::WarchestProgress, "Warchest Progress"},
+    {ToastState::WarchestFull, "Warchest Full"},
+    {ToastState::PartialVictory, "Partial Victory"},
+    {ToastState::ArenaTimeLeft, "Arena Time Warning"},
+    {ToastState::ChainedEventScored, "Event Progress"},
+    {ToastState::FleetPresetApplied, "Fleet Preset Applied"},
+    {ToastState::SurgeWarmUpEnded, "Surge Started"},
+    {ToastState::SurgeHostileGroupDefeated, "Surge Hostiles Defeated"},
+    {ToastState::SurgeTimeLeft, "Surge Time Warning"},
+    {ToastState::QueueForLeaseActivated, "Queue Activated"},
+    {ToastState::QueueForLeaseExpired, "Queue Expired"},
+    {ToastState::PermanentQueuePurchased, "Permanent Queue Purchased"},
+    {ToastState::OutpostStartedOrEnded, "Outpost Update"},
+    {ToastState::CrossAllianceArmadaVictory, "Cross-Armada Victory!"},
+    {ToastState::CrossAllianceArmadaDefeat, "Cross-Armada Defeated"},
+    {ToastState::CrossAllianceArmadaPartialVictory, "Cross-Armada Partial Victory"},
+    {ToastState::FactionWeeklyEventsProgress, "Faction Weekly Event Progress"},
+    {ToastState::FactionWeeklyEventsComplete, "Faction Weekly Event Complete"},
+    {ToastState::ArmadaPlayerBlocked, "Armada Player Blocked"},
+    {ToastState::ArmadaPlayerUnblocked, "Armada Player Unblocked"},
+    {ToastState::DynamicCrisisUpdate, "Dynamic Crisis Update"},
+    {ToastState::DynamicCrisisFailed, "Dynamic Crisis Failed"},
+    {ToastState::DynamicCrisisCompleted, "Dynamic Crisis Completed"},
+    {ToastState::GalacticAnomalySystemEntered, "Galactic Anomaly Entered"},
+};
+
+// Indexed by Digit.PrimePlatform.Models.EventCategories.
+constexpr const char* kEventCategories[] = {
+    "Standard",           "Daily Goals",          "Daily Milestone",    "Leaderboard",           "Stat",
+    "Battle Pass Season", "Battle Pass Event",    "Treasury Progress",  "Treasury Reward",       "Server Clash",
+    "Webstore Event",     "Player Lifecycle",     "Field Training",     "FT Category",           "Cutscenes",
+    "Minigame",           "Minigame Stage",       "Warchest",           "Alliance Game",         "Alliance Game Task",
+    "Meta Event",         "Meta Event Objective", "Invasion",           "Loop Museum",           "Loop Museum Task",
+    "PLC BP Season",      "PLC BP Event",         "Progression Reward", "Faction Weekly Events",
+};
+
+// Toasts whose Data is an EventModel; their body is prefixed with the event's category.
+constexpr ToastState kEventToasts[] = {ToastState::Achievement,
+                                       ToastState::Tournament,
+                                       ToastState::ChainedEventScored,
+                                       ToastState::TreasuryProgress,
+                                       ToastState::TreasuryFull,
+                                       ToastState::WarchestProgress,
+                                       ToastState::WarchestFull,
+                                       ToastState::FactionWeeklyEventsProgress,
+                                       ToastState::FactionWeeklyEventsComplete};
+
+// Toasts whose Data is a BattleResultHeader.
+constexpr ToastState kBattleToasts[] = {
+    ToastState::Victory,         ToastState::Defeat,           ToastState::PartialVictory, ToastState::StationVictory,
+    ToastState::StationDefeat,   ToastState::StationBattle,    ToastState::IncomingAttack, ToastState::FleetBattle,
+    ToastState::ArmadaBattleWon, ToastState::ArmadaBattleLost, ToastState::AssaultVictory, ToastState::AssaultDefeat};
+
+constexpr BattleType kPvpBattles[] = {BattleType::Fleet,       BattleType::Base,      BattleType::ArmadaBase,
+                                      BattleType::ArmadaAsb,   BattleType::ArmadaMta, BattleType::PvpCuttingBeam,
+                                      BattleType::PvpChainShot};
+
+template <typename T, size_t N> bool Contains(const T (&list)[N], T value)
+{ return std::ranges::find(list, value) != std::end(list); }
+
+// Toast data comes from a dozen game types whose layouts drift between builds. On Windows, an access violation
+// while reading one is contained and logged instead of taking the game down.
+using il2cpp::Guarded;
+
+// Localizes `identifier` with one parameter, guarded like the rest of the toast reads.
+std::string Localize(const char* identifier, const char* category, Il2CppObject* parameter)
+{
+  std::string result;
+  Guarded(identifier, [&] { result = LocaleUtilities::Localize(identifier, category, parameter); });
+  return result;
+}
+
+// NPC and marauder profiles have no name of their own; the game names them by their localization id.
+std::string EnemyName(int64_t loca_id)
+{ return loca_id ? Localize("marauder_name_only_{0}", "navigation", il2cpp::Box(loca_id)) : std::string{}; }
+
+// A hull's display name: localized by numeric id, then by string id, then derived from its internal key.
+std::string HullName(BattleResultHeader* header, int64_t hull_id)
+{
+  if (hull_id == 0)
+    return "";
+  auto* specs = header->specService();
+  auto* hull  = specs ? specs->GetHull(hull_id) : nullptr;
+  if (!hull)
+    return fmt::format("Hull#{}", hull_id);
+
+  // An unknown id localizes to the identifier itself.
+  if (auto* ids = hull->idRefs()) {
+    if (const auto loca_id = ids->locaId()) {
+      auto name = Localize("ship_name_{0}", "ships", il2cpp::Box(loca_id));
+      if (!name.empty() && name != fmt::format("ship_name_{}", loca_id))
+        return name;
+    }
+    if (auto* loca_string = ids->locaStringId(); loca_string && loca_string->length) {
+      const auto id   = il2cpp::ToUtf8(loca_string);
+      auto       name = Localize("ship_name_{0}", "ships", reinterpret_cast<Il2CppObject*>(loca_string));
+      if (!name.empty() && name != "ship_name_" + id)
+        return name;
+    }
+  }
+  auto* key = hull->name();
+  return key ? toast_text::HullKeyName(il2cpp::ToUtf8(key)) : fmt::format("Hull#{}", hull_id);
+}
+
+// "Player (Ship) vs Enemy (Ship)". Outside PvP a named enemy is enough; its hull class is noise.
+std::string BattleBody(BattleResultHeader* header)
+{
+  std::string player, enemy, player_ship, enemy_ship;
+  bool        pvp = false;
+
+  Guarded("the player profile", [&] {
+    if (auto* profile = header->PlayerUserProfile())
+      player = il2cpp::ToUtf8(profile->name());
+  });
+  Guarded("the enemy profile", [&] {
+    auto* profile = header->EnemyUserProfile();
+    if (!profile)
+      return;
+    enemy = il2cpp::ToUtf8(profile->name());
+    if (enemy.empty()) {
+      auto name = EnemyName(profile->locaId());
+      if (name != "Unknown")
+        enemy = std::move(name);
+    }
+  });
+  Guarded("the battle type", [&] { pvp = Contains(kPvpBattles, header->BattleType()); });
+  Guarded("the player hull",
+          [&] { player_ship = toast_text::TitleCase(HullName(header, header->PlayerShipHullId())); });
+  Guarded("the enemy hull", [&] { enemy_ship = toast_text::TitleCase(HullName(header, header->EnemyShipHullId())); });
+
+  const auto side = [](const std::string& name, const std::string& ship) {
+    return name.empty() ? ship : ship.empty() ? name : fmt::format("{} ({})", name, ship);
+  };
+  const auto left  = side(player, player_ship);
+  const auto right = !pvp && !enemy.empty() ? enemy : side(enemy, enemy_ship);
+  if (left.empty() || right.empty())
+    return left + right;
+  return left + " vs " + right;
+}
+
+// "[TAG] Owner started an Armada!\nLv.042 Target"
+std::string ArmadaCreatedBody(ArmadaCreatedData* data)
+{
+  std::string body;
+  Guarded("armada data", [&] {
+    auto* attack   = data ? data->ArmadaAttack() : nullptr;
+    auto* alliance = data ? data->Alliance() : nullptr;
+    auto* owner    = attack ? attack->Owner() : nullptr;
+    auto* target   = attack ? attack->TargetUserProfile() : nullptr;
+
+    const auto tag         = alliance ? il2cpp::ToUtf8(alliance->tag()) : std::string{};
+    auto       owner_name  = owner ? il2cpp::ToUtf8(owner->name()) : std::string{};
+    auto       target_name = target ? il2cpp::ToUtf8(target->name()) : std::string{};
+    if (target_name.empty() && target)
+      target_name = EnemyName(target->locaId());
+    if (owner_name.empty())
+      owner_name = "An alliance member";
+    if (target_name.empty() || target_name == "Unknown")
+      target_name = "Armada target";
+
+    const auto owner_label = tag.empty() ? owner_name : fmt::format("[{}] {}", tag, owner_name);
+    const auto level       = attack ? attack->TargetLevel() : 0;
+    body                   = fmt::format("{} started an Armada!\nLv.{:03} {}", owner_label, level, target_name);
+  });
+  return body;
+}
+
+// The string form of each element: strings as they are, everything else through its ToString override.
+std::vector<std::string> ParameterValues(il2cpp::Array<Il2CppObject*>* parameters)
+{
+  std::vector<std::string> values;
+  for (il2cpp_array_size_t i = 0; parameters && i < parameters->size(); ++i) {
+    auto*         element = (*parameters)[i];
+    Il2CppString* text    = nullptr;
+    if (element) {
+      Guarded("a text parameter", [&] { text = il2cpp::ToString(static_cast<il2cpp::Object*>(element)); });
+    }
+    values.push_back(il2cpp::ToUtf8(text));
+  }
+  return values;
+}
+
+// Fills placeholders from whichever array field of `object` resolves the most of them. The parameter array has
+// moved and been renamed between game builds, including generated backing fields, so this scans the runtime
+// fields rather than naming one.
+std::string FormatFromArrayFields(const std::string& text, Il2CppObject* object, std::string& fields_seen)
+{
+  auto best = text;
+  il2cpp::ForEachInstanceField(object, [&](FieldInfo* field) {
+    if (field->type->type != IL2CPP_TYPE_SZARRAY && field->type->type != IL2CPP_TYPE_ARRAY)
+      return;
+    auto* array = il2cpp::ReadField<il2cpp::Array<Il2CppObject*>*>(object, field);
+    fields_seen += fmt::format("{}{}[{}]", fields_seen.empty() ? "" : ", ", field->name,
+                               array ? std::to_string(array->size()) : "null");
+    if (!array || array->size() == 0)
+      return;
+    auto candidate = FormatPlaceholders(text, ParameterValues(array));
+    if (toast_text::CountPlaceholders(candidate) < toast_text::CountPlaceholders(best))
+      best = std::move(candidate);
+  });
+  return best;
+}
+
+// Fills placeholders from Toast.TextParameters, or failing that from any array on the toast or its text context.
+std::string FormatToastText(const std::string& text, Toast* toast, LocaleTextContext* context)
+{
+  if (auto* parameters = toast->TextParameters(); parameters && parameters->size() > 0)
+    return FormatPlaceholders(text, ParameterValues(parameters));
+
+  std::string fields_seen;
+  for (auto* source : {static_cast<Il2CppObject*>(toast), static_cast<Il2CppObject*>(context)})
+    if (auto result = FormatFromArrayFields(text, source, fields_seen); result != text)
+      return result;
+  if (text.find('{') != std::string::npos)
+    spdlog::warn("[Notify] Placeholders unresolved; array fields seen: {}. Template: \"{}\"",
+                 fields_seen.empty() ? "none" : fields_seen, text);
+  return text;
+}
+
+// The toast's own localized text with its parameters filled in.
+std::string ToastText(Toast* toast)
+{
+  auto* context = toast->TextLocaleTextContext();
+  if (!context) {
+    spdlog::debug("[Notify] No TextLocaleTextContext for toast state {}", static_cast<int>(toast->State()));
+    return {};
+  }
+
+  // LocaleUtilities.Localize fills the context's own parameters; the toast may carry them instead.
+  if (auto* text = LocaleUtilities::Localize(context, true, false)) {
+    auto result = il2cpp::ToUtf8(text);
+    return result.find('{') == std::string::npos ? result : FormatToastText(result, toast, context);
+  }
+
+  Il2CppString* text    = nullptr;
+  auto*         manager = LanguageManager::Instance();
+  if (!manager || !manager->Localize(text, context) || !text) {
+    spdlog::debug("[Notify] toast state {} could not be localized", static_cast<int>(toast->State()));
+    return {};
+  }
+  return FormatToastText(il2cpp::ToUtf8(text), toast, context);
+}
+
+std::string EventCategory(Toast* toast)
+{
+  auto*      data     = toast->Data();
+  auto*      event    = data ? data->As<EventModel>() : nullptr;
+  const auto category = event ? event->category() : -1;
+  return category >= 0 && category < static_cast<int32_t>(std::size(kEventCategories)) ? kEventCategories[category]
+                                                                                       : "";
+}
+
+std::string NotificationBody(Toast* toast)
+{
+  const auto  state = toast->State();
+  auto*       data  = toast->Data();
+  std::string body;
+  if (state == ToastState::ArmadaCreated)
+    body = ArmadaCreatedBody(static_cast<ArmadaCreatedData*>(data));
+  else if (auto* header = data && Contains(kBattleToasts, state) ? data->As<BattleResultHeader>() : nullptr)
+    body = BattleBody(header);
+  if (body.empty())
+    body = toast_text::StripRichText(ToastText(toast));
+  if (body.empty())
+    body = "(no details available)";
+
+  if (Contains(kEventToasts, state))
+    if (const auto category = EventCategory(toast); !category.empty())
+      body = category + " - " + body;
+  return body;
+}
+
+#if _WIN32
+void ShowWindowsNotification(const char* title, const std::string& body)
+{
+  // Notifications need a WinRT apartment on the game thread, set up by the first one. The game may already have
+  // one in another mode, which only matters if notifications then fail.
+  static const bool apartment = [] {
+    try {
+      winrt::init_apartment(winrt::apartment_type::single_threaded);
+    } catch (const winrt::hresult_error& e) {
+      spdlog::warn("[Notify] Windows notification service failed: {:#x} {}", static_cast<unsigned long>(e.code()),
+                   winrt::to_string(e.message()));
+    } catch (...) {
+      spdlog::warn("[Notify] Windows notification service failed (unknown error)");
+    }
+    return true;
+  }();
+  (void)apartment;
+  try {
+    using namespace winrt::Windows::UI::Notifications;
+    auto xml   = ToastNotificationManager::GetTemplateContent(ToastTemplateType::ToastText02);
+    auto nodes = xml.GetElementsByTagName(L"text");
+    nodes.Item(0).InnerText(winrt::to_hstring(title));
+    nodes.Item(1).InnerText(winrt::to_hstring(body));
+    ToastNotificationManager::CreateToastNotifier(L"Star Trek Fleet Command").Show(ToastNotification(xml));
+  } catch (const winrt::hresult_error& e) {
+    spdlog::warn("[Notify] WinRT notification failed: {}", winrt::to_string(e.message()));
+  } catch (...) {
+    spdlog::warn("[Notify] WinRT notification failed (unknown error)");
+  }
+}
+#endif
+
+// TODO: macOS has no notification delivery yet; the body code above runs on Windows only.
+void Notify(Toast* toast)
+{
+#if _WIN32
+  const auto  state = toast->State();
+  const auto& types = Config::Get().ui.notify_banner_types;
+  if (std::ranges::find(types, static_cast<int>(state)) == types.end())
+    return;
+  const auto title = std::ranges::find(kTitles, state, &std::pair<ToastState, const char*>::first);
+  if (title == std::end(kTitles)) {
+    spdlog::debug("[Notify] No title mapping for toast state {}, skipping", static_cast<int>(state));
+    return;
+  }
+  ShowWindowsNotification(title->second, NotificationBody(toast));
+#else
+  (void)toast;
+#endif
+}
+
+// Notifies, then reports whether the in-game banner should be shown.
+bool ShowBanner(Toast* toast)
+{
+  if (toast)
+    notification_audio_play(Config::Get().NotificationSoundForToast(static_cast<int>(toast->State())));
+  const auto& ui = Config::Get().ui;
+  if (!toast || (ui.disabled_banner_types.empty() && ui.notify_banner_types.empty()))
+    return true;
+  Notify(toast);
+  const auto& disabled = Config::Get().ui.disabled_banner_types;
+  return std::ranges::find(disabled, static_cast<int>(toast->State())) == disabled.end();
+}
+
+void ToastObserver_EnqueueToast_Hook(auto original, ToastObserver* _this, Toast* toast)
+{
+  if (ShowBanner(toast))
+    original(_this, toast);
+}
+
+void ToastObserver_EnqueueOrCombineToast_Hook(auto original, ToastObserver* _this, Toast* toast, uintptr_t compare)
+{
+  if (ShowBanner(toast))
+    original(_this, toast, compare);
+}
+
+void InstallToasts()
+{
+
+  IL2CPP_HOOK(ToastObserver::Class::Method("EnqueueToast"), ToastObserver_EnqueueToast_Hook);
+  IL2CPP_HOOK(ToastObserver::Class::Method("EnqueueOrCombineToast"), ToastObserver_EnqueueOrCombineToast_Hook);
+}
+} // namespace
+
+const Feature kToasts{"Toasts", &Config::Patches::toastbannerhooks, InstallToasts};
diff --git a/mods/src/patches/parts/tracked_objects.cc b/mods/src/patches/parts/tracked_objects.cc
new file mode 100644
index 000000000..32115f1b5
--- /dev/null
+++ b/mods/src/patches/parts/tracked_objects.cc
@@ -0,0 +1,44 @@
+// The game screens and widgets the shortcuts and labels look up through unity::Newest and unity::Instances. A class
+// left out here is never found there.
+
+#include "patches/patches.h"
+
+#include "prime/chat.h"
+#include "prime/fleet.h"
+#include "prime/inventory.h"
+#include "prime/navigation.h"
+#include "prime/officers.h"
+#include "prime/ui.h"
+#include "prime/viewers.h"
+
+#include <unity/tracker.h>
+
+namespace
+{
+void Install()
+{
+  unity::Track<PreScanTargetWidget>();
+  unity::Track<FleetBarViewController>();
+  unity::Track<FleetMeshSelector>();
+  unity::Track<AllianceStarbaseObjectViewerWidget>();
+  unity::Track<AnimatedRewardsScreenViewController>();
+  unity::Track<ArmadaObjectViewerWidget>();
+  unity::Track<ArtifactHallDetailsViewController>();
+  unity::Track<AssignShipsWidget>();
+  unity::Track<CelestialObjectViewerWidget>();
+  unity::Track<EmbassyObjectViewer>();
+  unity::Track<FullScreenChatViewController>();
+  unity::Track<HousingObjectViewerWidget>();
+  unity::Track<InventoryListViewController>();
+  unity::Track<MiningObjectViewerWidget>();
+  unity::Track<MissionsObjectViewerWidget>();
+  unity::Track<NavigationInteractionUIViewController>();
+  unity::Track<OfficerAssignmentViewController>();
+  unity::Track<ElementSelectorViewController>();
+  unity::Track<ShipManagementViewController>();
+  unity::Track<ShipManagementScreenStateViewController>();
+  unity::Track<StarNodeObjectViewerWidget>();
+}
+} // namespace
+
+const Feature kObjectTracker{"ObjectTracker", &Config::Patches::objecttracker, Install};
diff --git a/mods/src/patches/parts/transition_screen.cc b/mods/src/patches/parts/transition_screen.cc
deleted file mode 100644
index ee0309e48..000000000
--- a/mods/src/patches/parts/transition_screen.cc
+++ /dev/null
@@ -1,252 +0,0 @@
-#include "loading_screen_common.h"
-
-#include <spud/detour.h>
-
-namespace ls = ls_common;
-
-// Forward declarations — defined in loading_screen.cc / loading_tip.cc
-void ResetLoadingScreenState();
-void ResetLoadingTipState();
-
-namespace
-{
-struct Behaviour : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Behaviour">;
-
-  void SetEnabled(bool value)
-  { Set<"enabled">(value); }
-};
-
-struct TransitionViewController : Component {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.LoadingScreen", "TransitionViewController">;
-
-  Image* staticOverride()
-  { return Field<"_staticOverride", Image*>(); }
-  // The canvas Animator; Behaviour is enough to toggle it.
-  Behaviour* animator()
-  { return Field<"_animator", Behaviour*>(); }
-};
-
-struct SlideShowViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.SlideShow", "SlideShowViewController">;
-
-  Image* image()
-  { return Field<"_image", Image*>(); }
-};
-
-// The non-generic MonoSingleton base; its static PrepareAllForReload runs before a reload.
-using MonoSingletonBase = il2cpp::Class<"Assembly-CSharp", "", "MonoSingleton">;
-} // namespace
-
-// Per-TVC-instance state (reset in TVC.Awake)
-static bool        g_spriteApplied   = false;
-static Image*      g_bgImageComp     = nullptr;
-static Transform*  g_bgRectTransform = nullptr;
-static GameObject* g_bgOverlayGO     = nullptr;
-static GameObject* g_logoGO          = nullptr;
-static GameObject* g_ccLogoGO        = nullptr;
-static Behaviour*  g_canvasAnimator  = nullptr;
-
-// Called from PrepareAllForReload to null stale pointers before reload.
-// The Canvas/TVC hierarchy holding our overlays is replaced during
-// GoToLoginSection, which destroys the old overlays along with it.
-// Nulling here prevents TVC.Awake from touching stale/destroyed pointers.
-void ResetTransitionScreenState()
-{
-  g_spriteApplied   = false;
-  g_bgImageComp     = nullptr;
-  g_bgRectTransform = nullptr;
-  g_bgOverlayGO     = nullptr;
-  g_logoGO          = nullptr;
-  g_ccLogoGO        = nullptr;
-  g_canvasAnimator  = nullptr;
-  ResetLoadingScreenState();
-  ResetLoadingTipState();
-}
-
-// Finds the BG Image component on a TransitionViewController instance.
-// Tries TVC._staticOverride field first, then traverses children for "BGContainer".
-static Image* FindTVCBGImage(TransitionViewController* _this, Transform*& outRectTransform)
-{
-  if (auto* img = _this->staticOverride())
-    return img;
-
-  // Fallback: traverse children to find "BGContainer" → first child's Image
-  auto* root = _this->transform();
-  if (!root) return nullptr;
-
-  Transform* bgc = nullptr;
-  int32_t    n   = root->childCount();
-  for (int32_t i = 0; i < n; ++i) {
-    auto* ct = root->GetChild(i);
-    if (!ct) continue;
-    auto* cg = ct->gameObject();
-    if (cg && cg->Name() == "BGContainer") {
-      bgc = ct;
-      break;
-    }
-  }
-  if (!bgc || bgc->childCount() == 0) return nullptr;
-
-  auto* bgt = bgc->GetChild(0);
-  if (!bgt) return nullptr;
-  outRectTransform = bgt;
-  auto* bgg = bgt->gameObject();
-  return bgg ? bgg->GetComponent<Image>() : nullptr;
-}
-
-// Applies custom background and logos to a TransitionViewController.
-// Called from TVC.Awake (as fallback) and TVC.AboutToShow (primary).
-static void ApplyTransitionCustomization(TransitionViewController* _this)
-{
-  const auto& cfg = Config::Get();
-
-  // Find the BG image component
-  if (!g_bgImageComp) {
-    Transform* rt        = nullptr;
-    auto*      imageComp = FindTVCBGImage(_this, rt);
-    if (!imageComp) return;
-    g_bgImageComp     = imageComp;
-    g_bgRectTransform = rt;
-  }
-  auto* imageComp = g_bgImageComp;
-
-  // Determine logo parent transform
-  auto* logoParent = g_bgRectTransform ? g_bgRectTransform : imageComp->transform();
-
-  if (!g_canvasAnimator) {
-    if (auto* anim = _this->animator()) {
-      anim->SetEnabled(false);
-      g_canvasAnimator = anim;
-    }
-  }
-
-  if (cfg.loader_transition_black) {
-    if (logoParent) {
-      ls::CreateLogoOverlay(logoParent, g_logoGO);
-      ls::CreateCCLogoOverlay(logoParent, g_ccLogoGO);
-    }
-    g_spriteApplied = true;
-    return;
-  }
-
-#ifndef _USE_ORIGINAL_BG
-  if (logoParent && !g_bgOverlayGO) {
-    auto* asset = ls::GetLoadingAsset();
-    if (asset) g_bgOverlayGO = ls::CreateBGOverlay(logoParent, *asset);
-  }
-
-  // Preserve the game's background unless the custom replacement is fully
-  // constructed and attached. This keeps failures visible but harmless.
-  if (!g_bgOverlayGO) {
-    spdlog::warn("[LS] custom transition background unavailable; preserving game background");
-    return;
-  }
-
-  ls::HideImage(imageComp);
-
-  if (g_bgRectTransform) {
-    ls::SetFullRect(g_bgRectTransform->As<RectTransform>(), {0.0f, 0.0f}, {1.0f, 1.0f}, {0.5f, 0.5f},
-                    {0.0f, 0.0f}, {0.0f, 0.0f});
-    g_bgRectTransform->SetLocalEulerAngles({0, 0, 0});
-    g_bgRectTransform->SetLocalScale({1, 1, 1});
-  }
-#endif
-
-  if (logoParent) {
-    ls::CreateLogoOverlay(logoParent, g_logoGO);
-    ls::CreateCCLogoOverlay(logoParent, g_ccLogoGO);
-  }
-
-  if (auto* tvcTr = _this->transform()) {
-    int32_t n = tvcTr->childCount();
-    for (int32_t i = 0; i < n; ++i) {
-      auto* ct = tvcTr->GetChild(i);
-      if (!ct) continue;
-      auto* cg = ct->gameObject();
-      if (!cg) continue;
-      const auto name = cg->Name();
-      if (name == "LogoContainer") {
-        ls::SetFullRect(cg->GetComponent<RectTransform>(), {1.0f, 1.0f}, {1.0f, 1.0f}, {1.0f, 1.0f},
-                        {586.0f, 248.0f}, {-20.0f, -20.0f});
-      } else if (name == "LoadingTipsContainer") {
-        ls::SetFullRect(cg->GetComponent<RectTransform>(), {0.5f, 0.5f}, {0.5f, 0.5f}, {0.5f, 0.5f},
-                        {1024.0f, 100.0f}, {0.0f, -320.0f});
-      }
-    }
-  }
-
-  g_spriteApplied = true;
-}
-
-// --- Hooks ---
-
-static void TVC_Awake_Hook(auto original, TransitionViewController* _this)
-{
-  original(_this);
-
-  if (!Config::Get().loader_transition) return;
-
-  // A TransitionViewController can outlive the LoginSequence generation
-  // that created the cached Unity assets. Recreate them for this controller
-  // before touching its background hierarchy.
-  ls::ResetLoadingAssetsForScene();
-
-  g_spriteApplied   = false;
-  g_bgImageComp     = nullptr;
-  g_bgRectTransform = nullptr;
-  g_bgOverlayGO     = nullptr;
-  g_logoGO          = nullptr;
-  g_ccLogoGO        = nullptr;
-  g_canvasAnimator  = nullptr;
-
-  ApplyTransitionCustomization(_this);
-}
-
-static void TVC_AboutToShow_Hook(auto original, TransitionViewController* _this)
-{
-  original(_this);
-
-  if (!Config::Get().loader_transition || g_spriteApplied) return;
-  ApplyTransitionCustomization(_this);
-}
-
-static void TVC_AboutToHide_Hook(auto original, TransitionViewController* _this)
-{
-  if (Config::Get().loader_transition && g_canvasAnimator) {
-    // Re-enable canvas animator so the hide animation plays
-    g_canvasAnimator->SetEnabled(true);
-  }
-
-  original(_this);
-}
-
-static void SlideShowViewer_ShowCurrentSlide_Hook(auto original, SlideShowViewController* _this)
-{
-  original(_this);
-
-  const auto& cfg = Config::Get();
-  if (!cfg.loader_transition || cfg.loader_transition_black) return;
-
-  ls::HideImage(_this->image());
-}
-
-static void TS_MonoSingleton_PrepareAllForReload_Hook(auto original)
-{
-  ResetTransitionScreenState();
-  original();
-}
-
-void InstallTransitionScreenHooks()
-{
-  if (auto m = TransitionViewController::Class::Method("Awake"))
-    SPUD_STATIC_DETOUR(m.Pointer(), TVC_Awake_Hook);
-  if (auto m = TransitionViewController::Class::Method("AboutToShow"))
-    SPUD_STATIC_DETOUR(m.Pointer(), TVC_AboutToShow_Hook);
-  if (auto m = TransitionViewController::Class::Method("AboutToHide"))
-    SPUD_STATIC_DETOUR(m.Pointer(), TVC_AboutToHide_Hook);
-  if (auto m = SlideShowViewController::Class::Method("ShowCurrentSlide"))
-    SPUD_STATIC_DETOUR(m.Pointer(), SlideShowViewer_ShowCurrentSlide_Hook);
-  if (auto m = MonoSingletonBase::Method("PrepareAllForReload"))
-    SPUD_STATIC_DETOUR(m.Pointer(), TS_MonoSingleton_PrepareAllForReload_Hook);
-}
diff --git a/mods/src/patches/parts/ui_scale.cc b/mods/src/patches/parts/ui_scale.cc
index 78736ef74..0a91104ca 100644
--- a/mods/src/patches/parts/ui_scale.cc
+++ b/mods/src/patches/parts/ui_scale.cc
@@ -1,54 +1,47 @@
-#include "patches/object_tracker.h"
-#include <config.h>
+// UI, object viewer, and system ship scaling, and the hotkeys that adjust them at runtime.
 
-#include <il2cpp/il2cpp.h>
+#include "config.h"
+#include "patches/patches.h"
+#include "str_utils.h"
 
-#include <prime/CanvasScaler.h>
-#include <prime/FleetMeshSelector.h>
-#include <prime/ScreenManager.h>
-#include <prime/Transform.h>
+#include "prime/fleet.h"
+#include "prime/ui.h"
 
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
+#include <unity/tracker.h>
+#include <unity/ui.h>
+
+#include <algorithm>
+#include <cmath>
 
-#include <prime/Vector3.h>
-#include <str_utils.h>
+#if _WIN32
+#include <Windows.h>
+#endif
 
 namespace
 {
 float ShipScaleMultiplier()
 {
-  const auto multiplier = Config::Get().ui_scale_ship;
+  const auto multiplier = Config::Get().graphics.ui_scale_ship;
   return multiplier > 0.0f ? multiplier : 1.0f;
 }
 
-Transform* GetGameObjectTransform(GameObject* game_object)
+// Ships already in the system keep the scale they were loaded with, so rescale them by the change.
+void RescaleLoadedShips(float old_multiplier, float new_multiplier)
 {
-  return game_object ? game_object->Get<"transform", Transform*>() : nullptr;
-}
-} // namespace
-
-void ApplyUiShipScaleToLoadedShips(float old_multiplier, float new_multiplier)
-{
-  if (old_multiplier <= 0.0f || new_multiplier <= 0.0f) {
+  if (old_multiplier <= 0.0f || new_multiplier <= 0.0f)
     return;
-  }
 
   const auto ratio = new_multiplier / old_multiplier;
-
-  for (auto* selector : ObjectFinder<FleetMeshSelector>::GetAll()) {
-    if (selector == nullptr) {
+  for (auto* selector : unity::Instances<FleetMeshSelector>()) {
+    auto* object    = selector ? selector->LoadedObject() : nullptr;
+    auto* transform = object ? object->transform() : nullptr;
+    if (!transform)
       continue;
-    }
-
-    auto* transform = GetGameObjectTransform(selector->LoadedObject());
-    if (transform == nullptr) {
-      continue;
-    }
-
-    auto    local_scale = transform->localScale();
-    Vector3 adjusted_scale{local_scale.x * ratio, local_scale.y * ratio, local_scale.z * ratio};
-    transform->SetLocalScale(adjusted_scale);
+    const auto scale = transform->localScale();
+    transform->SetLocalScale({scale.x * ratio, scale.y * ratio, scale.z * ratio});
   }
 }
 
@@ -56,9 +49,8 @@ bool SystemViewShip_TryGetShipAssetBundleResource_Hook(auto original, void* _thi
                                                        void** asset_bundle_resource)
 {
   const auto result = original(_this, scale, asset_bundle_resource);
-  if (result && scale != nullptr) {
+  if (result && scale)
     *scale *= ShipScaleMultiplier();
-  }
   return result;
 }
 
@@ -66,64 +58,82 @@ void ScreenManager_UpdateCanvasRootScaleFactor_Hook(auto original, ScreenManager
 {
   original(_this);
 
-  #if _WIN32
-  static auto cursor = LoadCursor(NULL, IDC_ARROW);
-  if (!Config::Get().allow_cursor) {
+#if _WIN32
+  static auto cursor = LoadCursor(nullptr, IDC_ARROW);
+  if (!Config::Get().graphics.allow_cursor)
     SetCursor(cursor);
-  }
-  #endif
-
-  if (Config::Get().ui_scale != 0.0f) {
-    static auto get_height_method = il2cpp::ResolveICall<int()>("UnityEngine.Screen::get_height()");
-    static auto get_width_method  = il2cpp::ResolveICall<int()>("UnityEngine.Screen::get_width()");
-
-    static auto ref_height = 1080;
-    static auto ref_width  = 1920;
-
-    auto scr_height = (float)get_height_method();
-    auto scr_width  = (float)get_width_method();
-    auto dpi        = Config::GetDPI();
-
-    auto adjustedFactor = scr_height / (float)ref_height;
+#endif
 
-    if (!Config::Get().adjust_scale_res) {
-      adjustedFactor = 1.0f;
-    }
-
-    auto n = (Config::Get().ui_scale * adjustedFactor * dpi);
-    if (isnan(n)) {
-      n = 1.0f;
-    }
-    n = std::clamp(n, 0.1f, 5.0f);
+  const auto ui_scale = Config::Get().graphics.ui_scale;
+  if (ui_scale == 0.0f)
+    return;
 
-    // Property setter, not the managed SetScaleFactor method; the scaler applies it on its next Update.
-    if (auto* scaler = _this->canvasRootScaler())
-      scaler->set_scaleFactor(n);
-  }
+  auto factor = ui_scale * WindowDpiScale();
+  factor      = std::isnan(factor) ? 1.0f : std::clamp(factor, 0.1f, 5.0f);
+  if (auto* scaler = _this->canvasRootScaler())
+    scaler->SetScaleFactor(factor);
 }
 
-void CanvasController_Show(auto original, CanvasController* _this, int desiredEntryPoint, bool instant)
+void CanvasController_Show_Hook(auto original, CanvasController* _this, int desiredEntryPoint, bool instant)
 {
-  const auto ui_scale_viewer = Config::Get().ui_scale_viewer;
-  if (_this && ui_scale_viewer != 0.0f && to_wstring(_this->name()) == L"ObjectViewerTemplate_Canvas") {
+  const auto viewer_scale = Config::Get().graphics.ui_scale_viewer;
+  if (_this && viewer_scale != 0.0f && il2cpp::Equals(_this->name(), "ObjectViewerTemplate_Canvas")) {
     if (auto* transform = _this->transform())
-      transform->SetLocalScale(Vector3{ui_scale_viewer, ui_scale_viewer, ui_scale_viewer});
+      transform->SetLocalScale({viewer_scale, viewer_scale, viewer_scale});
   }
   return original(_this, desiredEntryPoint, instant);
 }
 
-void InstallUiScaleHooks()
+void InstallUiScale()
 {
-  using SystemViewShip = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "SystemViewShip">;
+  IL2CPP_HOOK(SystemViewShip::Method("TryGetShipAssetBundleResource", 2),
+              SystemViewShip_TryGetShipAssetBundleResource_Hook);
 
-  if (auto method = SystemViewShip::Method("TryGetShipAssetBundleResource", 2))
-    SPUD_STATIC_DETOUR(method.Pointer(), SystemViewShip_TryGetShipAssetBundleResource_Hook);
+  IL2CPP_HOOK(ScreenManager::Class::Method("UpdateCanvasRootScaleFactor"),
+              ScreenManager_UpdateCanvasRootScaleFactor_Hook);
 
-  if (auto method = ScreenManager::Class::Method("UpdateCanvasRootScaleFactor"))
-    SPUD_STATIC_DETOUR(method.Pointer(), ScreenManager_UpdateCanvasRootScaleFactor_Hook);
+  IL2CPP_HOOK(CanvasController::Class::Method("Show", {"System.Int32", "System.Boolean"}), CanvasController_Show_Hook);
 
-  if (auto method = CanvasController::Class::Method("Show", {"System.Int32", "System.Boolean"}))
-    SPUD_STATIC_DETOUR(method.Pointer(), CanvasController_Show);
+  WindowDpiScale(true);
+}
+} // namespace
 
-  Config::RefreshDPI();
+void AdjustUiScale(bool up)
+{
+  auto& config = Config::Get();
+  if (config.graphics.ui_scale == 0.0f)
+    return;
+
+  const auto old_scale     = config.graphics.ui_scale;
+  const auto new_scale     = old_scale + (up ? 1.0f : -1.0f) * config.graphics.ui_scale_step;
+  config.graphics.ui_scale = std::clamp(new_scale, 0.1f, 2.0f);
+  spdlog::info("UI has been scaled {}, was {}, now {} (unclamped {}) @ {} DPI Scaling", up ? "UP" : "DOWN", old_scale,
+               config.graphics.ui_scale, new_scale, WindowDpiScale(true));
 }
+
+void AdjustUiViewerScale(bool up)
+{
+  auto& config = Config::Get();
+  if (config.graphics.ui_scale_viewer == 0.0f)
+    return;
+
+  // Viewers change in quarter steps; a full step is too coarse at their size.
+  const auto old_scale            = config.graphics.ui_scale_viewer;
+  const auto new_scale            = old_scale + (up ? 1.0f : -1.0f) * config.graphics.ui_scale_step * 0.25f;
+  config.graphics.ui_scale_viewer = std::clamp(new_scale, 0.1f, 2.0f);
+  spdlog::info("UI Viewer has been scaled {}, was {}, now {} (unclamped {})", up ? "UP" : "DOWN", old_scale,
+               config.graphics.ui_scale_viewer, new_scale);
+}
+
+void AdjustUiShipScale(bool up)
+{
+  auto&      config             = Config::Get();
+  const auto old_scale          = config.graphics.ui_scale_ship;
+  const auto new_scale          = old_scale + (up ? 1.0f : -1.0f) * config.graphics.ui_scale_step;
+  config.graphics.ui_scale_ship = std::clamp(new_scale, 0.1f, 20.0f);
+  spdlog::info("System ship models have been scaled {}, was {}, now {} (unclamped {})", up ? "UP" : "DOWN", old_scale,
+               config.graphics.ui_scale_ship, new_scale);
+  RescaleLoadedShips(old_scale, config.graphics.ui_scale_ship);
+}
+
+const Feature kUiScale{"UiScale", &Config::Patches::uiscalehooks, InstallUiScale};
diff --git a/mods/src/patches/parts/warp_action_label.cc b/mods/src/patches/parts/warp_action_label.cc
deleted file mode 100644
index 3a01dd54b..000000000
--- a/mods/src/patches/parts/warp_action_label.cc
+++ /dev/null
@@ -1,135 +0,0 @@
-#include "config.h"
-#include "patches/object_tracker.h"
-
-#include "patches/instant_warp_policy.h"
-#include "patches/screen_update_hook.h"
-#include "prime/DeploymentManager.h"
-#include "prime/FleetsManager.h"
-#include "prime/StarNodeObjectViewerWidget.h"
-#include "prime/TextLocalizer.h"
-#include "str_utils.h"
-#include <il2cpp/il2cpp.h>
-#include <spdlog/spdlog.h>
-
-#include <chrono>
-#include <stdexcept>
-
-namespace
-{
-// This is a client of the existing frame dispatcher, not another UI detour.
-// Never mutate the button context, timer, resource cost, or click handler.
-// Unity's `bool(UnityEngine.Object)`: false for null and for destroyed native objects.
-bool Alive(il2cpp::Object* object)
-{
-  using UnityObject = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Object">;
-  return object && UnityObject::Call<"op_Implicit", bool>(object);
-}
-
-std::string CurrentText(TextLocalizer* label)
-{
-  auto* text = label->CurrentText();
-  if (!text)
-    throw std::runtime_error("expected label text");
-  return to_string(text);
-}
-
-struct OwnedLabel {
-  il2cpp::GcHandle handle;
-  std::string      text;
-
-  TextLocalizer* Get() const
-  { return handle.Get<TextLocalizer>(); }
-
-  void Clear()
-  {
-    auto* label    = Get();
-    auto  previous = std::move(text);
-    handle.Reset();
-    text.clear();
-    // Forget ownership even if native cleanup fails.
-    if (Alive(label) && label->textOverride() && CurrentText(label) == previous)
-      label->ClearTextOverride();
-  }
-
-  void Apply(TextLocalizer* label, const char* desired)
-  {
-    if (!label || !desired) {
-      Clear();
-      return;
-    }
-    if (Get() != label) {
-      Clear();
-      // Don't take ownership from an existing text override.
-      if (label->textOverride())
-        return;
-      handle = il2cpp::GcHandle::Weak(label);
-      if (!handle)
-        return;
-    }
-    const auto current = CurrentText(label);
-    if (!text.empty() && label->textOverride() && current != text) {
-      Clear();
-      return;
-    }
-    if (text == desired && label->textOverride() && current == desired)
-      return;
-    label->OverrideLocalizedText(il2cpp_string_new(desired));
-    text = desired;
-  }
-};
-OwnedLabel action_label;
-
-void Update()
-{
-  static auto next = std::chrono::steady_clock::time_point{};
-  const auto  now  = std::chrono::steady_clock::now();
-  if (now < next)
-    return;
-  next = now + std::chrono::milliseconds(100);
-  try {
-    auto*       widget  = ObjectFinder<StarNodeObjectViewerWidget>::Get();
-    const bool  active  = Alive(widget) && widget->isActiveAndEnabled();
-    auto*       button  = active ? widget->visitButton() : nullptr;
-    const bool  enabled = Alive(button) && button->isActiveAndEnabled() && button->Interactable();
-    const char* desired = nullptr;
-    // The ordinary visit path uses the currently selected fleet. The card's
-    // cached popup CourseData is populated on click, so it is not a preview source.
-    // Toll/wormhole buttons have separate confirmation paths and retain native text.
-    if (enabled) {
-      auto* fleets     = FleetsManager::Instance();
-      auto* deployment = DeploymentManger::Instance();
-      auto* fleet      = Alive(fleets) ? fleets->GetSelectedFleetData() : nullptr;
-      if (fleet && Alive(deployment) && deployment->HasInstantWarpAbility(fleet)) {
-        switch (ResolveInstantWarpConfirmation(fleet)) {
-          case InstantWarpConfirmation::Warp:
-            desired = "WARP";
-            break;
-          case InstantWarpConfirmation::Jump:
-            desired = "JUMP";
-            break;
-          case InstantWarpConfirmation::None:
-            break;
-        }
-      }
-    }
-    auto* label = desired ? button->mainText() : nullptr;
-    action_label.Apply(Alive(label) ? label : nullptr, desired);
-  } catch (const std::exception& error) {
-    static bool warned = false;
-    if (!warned) {
-      warned = true;
-      spdlog::warn("[WarpActionLabel] native label unavailable: {}", error.what());
-    }
-    try {
-      action_label.Clear();
-    } catch (...) {
-    }
-  }
-}
-} // namespace
-
-void InstallWarpActionLabel()
-{
-  if (install_screen_manager_update_hook() && register_screen_manager_update_callback(Update))
-    spdlog::info("[WarpActionLabel] system-card action labels enabled");
-}
diff --git a/mods/src/patches/parts/window.cc b/mods/src/patches/parts/window.cc
new file mode 100644
index 000000000..ccafe2c87
--- /dev/null
+++ b/mods/src/patches/parts/window.cc
@@ -0,0 +1,142 @@
+// The game window on Windows: free resizing, the -ccm profile in the title bar, allow_cursor, and the monitor's DPI
+// scale.
+
+#include "patches/patches.h"
+
+#if _WIN32
+#include "config.h"
+#include "file.h"
+#include "prime/Hub.h"
+#include <unity/ui.h>
+
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
+
+#include <Windows.h>
+
+#include <string>
+
+namespace
+{
+// The first visible, unowned top-level window of this process. Found once it exists, then cached.
+HWND GameWindow()
+{
+  static HWND window = nullptr;
+  if (window)
+    return window;
+
+  const auto process = GetCurrentProcessId();
+  for (auto hwnd = GetTopWindow(nullptr); hwnd; hwnd = GetNextWindow(hwnd, GW_HWNDNEXT)) {
+    DWORD owner_process = 0;
+    GetWindowThreadProcessId(hwnd, &owner_process);
+    if (owner_process == process && !GetWindow(hwnd, GW_OWNER) && IsWindowVisible(hwnd)) {
+      window = hwnd;
+      break;
+    }
+  }
+  return window;
+}
+
+// With several clients running, "-ccm alt.toml" shows up as "[alt] Star Trek Fleet Command".
+bool ApplyProfileTitle()
+{
+  auto* window = GameWindow();
+  if (!window)
+    return false;
+
+  const auto length = GetWindowTextLengthW(window);
+  if (length == 0)
+    return false;
+  std::wstring title(static_cast<size_t>(length) + 1, L'\0');
+  title.resize(GetWindowTextW(window, title.data(), length + 1));
+
+  const auto&  profile = File::Profile();
+  std::wstring prefix(MultiByteToWideChar(CP_UTF8, 0, profile.data(), static_cast<int>(profile.size()), nullptr, 0),
+                      L'\0');
+  MultiByteToWideChar(CP_UTF8, 0, profile.data(), static_cast<int>(profile.size()), prefix.data(),
+                      static_cast<int>(prefix.size()));
+  return SetWindowTextW(window, (L"[" + prefix + L"] " + title).c_str()) != 0;
+}
+
+// TODO: the old hook also stretched a 1024x768 fullscreen fallback to the monitor, but only once a window
+// handle captured by a SetWindowLongW detour was set, and that detour was never installed. Bring it back
+// with a tested trigger if the fallback is still seen.
+// With free_resize the original is skipped: the game's per-frame aspect-ratio enforcement is what would snap the
+// window back.
+void AspectRatioConstraintHandler_Update_Hook(auto original, void* _this)
+{
+  static bool title_pending = !File::Profile().empty();
+  if (title_pending && ApplyProfileTitle())
+    title_pending = false;
+  if (!Config::Get().graphics.free_resize)
+    original(_this);
+}
+
+// allow_cursor = false: the plain arrow, never clipped to the window.
+void Cursor_SetCursor_Hook(auto original, void* _this, ptrdiff_t texture, unity::Vector2* hotspot, int mode)
+{
+  if (Config::Get().graphics.allow_cursor)
+    return original(_this, texture, hotspot, mode);
+  SetCursor(LoadCursor(NULL, IDC_ARROW));
+  ClipCursor(nullptr);
+}
+
+intptr_t AspectRatioConstraintHandler_WndProc_Hook(auto original, HWND hWnd, uint32_t msg, intptr_t wParam,
+                                                   intptr_t lParam)
+{
+  // Skip the game's aspect-ratio clamp and hand the message straight to Unity. The message arrives in the form of
+  // the window's current procedure (the game's, installed through its own P/Invoke), and the A and W calls each
+  // convert from their own form; the wrong one garbles non-ASCII text such as chat input.
+  if (Config::Get().graphics.free_resize) {
+    const auto forward = IsWindowUnicode(hWnd) ? CallWindowProcW : CallWindowProcA;
+    return forward(reinterpret_cast<WNDPROC>(AspectRatioConstraintHandler::unityWndProc()), hWnd, msg, wParam, lParam);
+  }
+  return original(hWnd, msg, wParam, lParam);
+}
+
+void InstallFreeResize()
+{
+  auto update  = AspectRatioConstraintHandler::Class::Method("Update");
+  auto wndproc = AspectRatioConstraintHandler::Class::Method("WndProc");
+  if (!update || !wndproc)
+    return;
+
+  IL2CPP_HOOK(update, AspectRatioConstraintHandler_Update_Hook);
+  IL2CPP_HOOK(wndproc, AspectRatioConstraintHandler_WndProc_Hook);
+}
+
+void InstallCursor()
+{ IL2CPP_HOOK(unity::Cursor::Method("SetCursor_Injected"), Cursor_SetCursor_Hook); }
+} // namespace
+
+float WindowDpiScale(bool refresh)
+{
+  static HMONITOR last_monitor = nullptr;
+  static float    scale        = 1.0f;
+
+  // The game's own window, not GetActiveWindow(): that is null while the game is in the background, which would
+  // pick the primary monitor.
+  const auto monitor = MonitorFromWindow(GameWindow(), MONITOR_DEFAULTTONEAREST);
+  if (!refresh && monitor == last_monitor)
+    return scale;
+
+  MONITORINFOEX info{};
+  info.cbSize = sizeof(info);
+  DEVMODE mode{};
+  mode.dmSize = sizeof(mode);
+  if (GetMonitorInfo(monitor, &info) && EnumDisplaySettings(info.szDevice, ENUM_CURRENT_SETTINGS, &mode)) {
+    const auto logical_width = info.rcMonitor.right - info.rcMonitor.left;
+    if (logical_width > 0)
+      scale = static_cast<float>(mode.dmPelsWidth) / static_cast<float>(logical_width);
+  }
+  last_monitor = monitor;
+  return scale;
+}
+
+const Feature kFreeResize{"FreeResize", &Config::Patches::freeresizehooks, InstallFreeResize};
+// TODO: allow_cursor is not a test patch; it sits in testpatches only because it always has.
+const Feature kCursor{"Cursor", &Config::Patches::testpatches, InstallCursor};
+#else
+float WindowDpiScale(bool)
+{ return 1.0f; }
+#endif
diff --git a/mods/src/patches/parts/zoom.cc b/mods/src/patches/parts/zoom.cc
index 49bc8fb6f..a30ab5263 100644
--- a/mods/src/patches/parts/zoom.cc
+++ b/mods/src/patches/parts/zoom.cc
@@ -1,609 +1,355 @@
+// The camera in system view and at the station: the extended zoom range, keyboard zoom and its presets, planet
+// sprite scaling, keyboard panning, pan momentum and the target camera lock, keyboard rotation around the station, and
+// held touches that keep panning. Fleet label detail, which follows the zoom, is in fleet_labels.cc.
+
 #include "config.h"
+#include "patches/patches.h"
+#include "patches/shortcuts.h"
 
-#include <patches/mapkey.h>
+#include "prime/Hub.h"
+#include "prime/navigation.h"
+#include "prime/ui.h"
 
+#include <il2cpp/hook.h>
 #include <il2cpp/il2cpp.h>
-
-#include <prime/NavigationFleetWidget.h>
-#include <prime/NavigationLOD.h>
-#include <prime/NavigationPan.h>
-#include <prime/NavigationZoom.h>
-#include <prime/PlanetViewUtils.h>
-#include <prime/Transform.h>
-
 #include <spdlog/spdlog.h>
-#include <spud/detour.h>
+#include <unity/input.h>
+#include <unity/ui.h>
 
-#include <cstdint>
+#include <cmath>
+#include <optional>
+#include <ranges>
 #include <unordered_map>
+#include <utility>
 
 namespace
 {
-std::unordered_map<NavigationLOD *, NavigationFleetWidget *> fleet_label_widgets;
-bool                                                         fleet_label_hooks_installed         = false;
-uintptr_t                                                    active_system_zoom_id               = 0;
-bool                                                         system_zoom_state_valid             = false;
-ZoomLevels                                                   system_zoom_level                   = ZoomLevels::None;
-float                                                        system_normalized_zoom              = 0.0f;
-bool                                                         threshold_state_valid               = false;
-bool                                                         player_threshold_state_expanded     = false;
-bool                                                         non_player_threshold_state_expanded = false;
-
-bool FleetLabelProfilesEnabled()
-{
-  const auto &config = Config::Get();
-  return config.zoom_label_player.detail != FleetLabelDetail::Native
-         || config.zoom_label_non_player.detail != FleetLabelDetail::Native;
-}
+// --- Zoom ---
 
-bool FleetLabelThresholdEnabled()
-{
-  const auto &config = Config::Get();
-  return config.zoom_label_player.detail == FleetLabelDetail::Threshold
-         || config.zoom_label_non_player.detail == FleetLabelDetail::Threshold;
-}
+// Entering a system jumps to default_system_zoom on the next camera update.
+bool zoom_to_default = false;
 
-const FleetLabelProfile *FleetLabelProfileFor(NavigationFleetWidget *widget)
-{
-  if (widget == nullptr) {
-    return nullptr;
-  }
-
-  const auto &config  = Config::Get();
-  auto       *context = widget->Context();
-  if (context == nullptr) {
-    return &config.zoom_label_non_player;
-  }
-
-  // A missing FleetType property reads as Nonexistent.
-  switch (context->FleetType()) {
-    case DeployedFleetType::Player:
-      return &config.zoom_label_player;
-    case DeployedFleetType::Marauder:
-    case DeployedFleetType::NpcInstantiated:
-    case DeployedFleetType::Sentinel:
-    case DeployedFleetType::Alliance:
-    case DeployedFleetType::Challenge:
-      return &config.zoom_label_non_player;
-    case DeployedFleetType::Nonexistent:
-    default:
-      return &config.zoom_label_non_player;
-  }
-}
-
-const FleetLabelProfile *FleetLabelProfileFor(NavigationLOD *lod)
-{
-  const auto widget = fleet_label_widgets.find(lod);
-  if (widget == fleet_label_widgets.end() || widget->second == nullptr || widget->second->Context() == nullptr) {
-    return nullptr;
-  }
-  return FleetLabelProfileFor(widget->second);
-}
-
-ZoomLevels ExpandedFleetLabelZoomLevel(ZoomLevels native_level)
-{ return native_level == ZoomLevels::Near ? ZoomLevels::Near : ZoomLevels::Middle; }
-
-bool FleetLabelsExpandedAt(float normalized_zoom, float threshold)
-{
-  if (threshold <= 0.0f) {
-    return false;
-  }
-  if (threshold >= 1.0f) {
-    return true;
-  }
-  return normalized_zoom <= threshold;
-}
+// Camera distance as a share of the zoom range, scaled to the configured maximum (the unit the presets use).
+float CurrentZoom(NavigationZoom* zoom)
+{ return (zoom->Distance() - zoom->minimum()) / (zoom->maximum() - zoom->minimum()) * Config::Get().graphics.zoom; }
 
-ZoomLevels FleetLabelZoomLevel(ZoomLevels native_level, const FleetLabelProfile &profile)
+void StorePreset(const char* label, float& preset, NavigationZoom* zoom)
 {
-  switch (profile.detail) {
-    case FleetLabelDetail::Expanded:
-      return ExpandedFleetLabelZoomLevel(native_level);
-    case FleetLabelDetail::Compact:
-      return ZoomLevels::Far;
-    case FleetLabelDetail::Threshold:
-      if (!system_zoom_state_valid) {
-        return native_level;
-      }
-      return FleetLabelsExpandedAt(system_normalized_zoom, profile.zoom_threshold)
-                 ? ExpandedFleetLabelZoomLevel(native_level)
-                 : ZoomLevels::Far;
-    case FleetLabelDetail::Native:
-    default:
-      return native_level;
-  }
+  const auto old = preset;
+  preset         = CurrentZoom(zoom);
+  spdlog::info("Changing {} from {} to {}", label, old, preset);
 }
 
-void ApplyFleetLabelDetail(NavigationLOD *lod, ZoomLevels native_level)
+struct Preset {
+  Action store;
+  Action go;
+  float Config::Graphics::* value;
+  const char*               label;
+};
+
+constexpr Preset kPresets[] = {
+    {Action::kSetZoomPreset1, Action::kZoomPreset1, &Config::Graphics::system_zoom_preset_1, "System Preset 1"},
+    {Action::kSetZoomPreset2, Action::kZoomPreset2, &Config::Graphics::system_zoom_preset_2, "System Preset 2"},
+    {Action::kSetZoomPreset3, Action::kZoomPreset3, &Config::Graphics::system_zoom_preset_3, "System Preset 3"},
+    {Action::kSetZoomPreset4, Action::kZoomPreset4, &Config::Graphics::system_zoom_preset_4, "System Preset 4"},
+    {Action::kSetZoomPreset5, Action::kZoomPreset5, &Config::Graphics::system_zoom_preset_5, "System Preset 5"},
+};
+
+// Widens the system view's zoom range to the configured maximum and pushes the far clip plane out with it.
+void ApplyZoomRange(NavigationZoom* zoom, float radius)
 {
-  if (lod == nullptr || !system_zoom_state_valid || FleetLabelProfileFor(lod) == nullptr) {
-    return;
+  const auto max_zoom = Config::Get().graphics.zoom;
+  if (radius > 0.0f) {
+    zoom->SetFarRatioSystemNormal(0.55f * max_zoom / radius);
+    zoom->SetFarRatioSystemExtended(max_zoom / radius);
   }
-
-  lod->UpdateLOD(native_level);
-}
-
-void ApplyAllFleetLabelDetails()
-{
-  for (const auto &[lod, widget] : fleet_label_widgets) {
-    (void)widget;
-    ApplyFleetLabelDetail(lod, system_zoom_level);
+  if (auto* camera = zoom->sceneCamera()) {
+    camera->SetFarClipPlane(max_zoom * 3.75f);
+    camera->SetClearFlags(unity::Camera::ClearFlags::SolidColor);
+    camera->SetBackgroundColor({0, 0, 0, 0});
   }
 }
 
-void RestoreNativeFleetLabelDetail(NavigationLOD *lod)
+// The game resets the range now and then; reapply it around every update.
+void KeepZoomRange(NavigationZoom* zoom)
 {
-  if (lod == nullptr || !system_zoom_state_valid) {
+  const auto max_zoom = Config::Get().graphics.zoom;
+  if (zoom->depth() != NodeDepth::SolarSystem || max_zoom <= 0.0f)
     return;
-  }
-
-  lod->SetTargetLevel(system_zoom_level);
-  lod->UpdateLOD(system_zoom_level);
-  lod->SetTargetLevel(system_zoom_level);
+  ApplyZoomRange(zoom, zoom->viewRadius());
+  if (zoom->maximum() < max_zoom)
+    zoom->SetMaximum(max_zoom);
+  if (const auto total = zoom->maximum() - zoom->minimum(); total > 0.0f)
+    zoom->SetZoomtotal(total);
 }
 
-void ResetFleetLabelSystemState()
+// Zooms around the mouse pointer, either by `delta` or (with `absolute`) to a preset value.
+void ZoomAtMouse(NavigationZoom* zoom, float value, bool absolute)
 {
-  active_system_zoom_id   = 0;
-  system_zoom_state_valid = false;
-  system_zoom_level       = ZoomLevels::None;
-  system_normalized_zoom  = 0.0f;
-  threshold_state_valid   = false;
-}
-
-void BeginFleetLabelSystemState(NavigationZoom *zoom)
-{
-  const auto zoom_id = reinterpret_cast<uintptr_t>(zoom);
-  if (active_system_zoom_id != zoom_id) {
-    ResetFleetLabelSystemState();
-    active_system_zoom_id = zoom_id;
+  const auto mouse = unity::Input::mousePosition();
+  zoom->SetZoomLocation({mouse.x, mouse.y});
+  if (absolute) {
+    zoom->SetDistance(zoom->minimum() + (zoom->maximum() - zoom->minimum()) * (value / Config::Get().graphics.zoom));
+  } else {
+    zoom->SetZoomDelta(value);
+    zoom->SetLastZoomDelta(value);
   }
+  auto* camera = zoom->sceneCamera();
+  zoom->SetWorldPoint(camera ? MathUtils::GetMouseWorldPos(camera, mouse) : unity::Vector3{});
+  zoom->ZoomCameraAtWorldPoint();
 }
 
-void UpdateFleetLabelThreshold()
+// Keyboard zoom: Q/E zoom by keyboard_zoom_speed per second, presets jump, SHIFT-F1.. store the current zoom.
+// Returns false when a preset was stored, which skips the game's update for that frame.
+bool KeyboardZoom(NavigationZoom* zoom)
 {
-  if (!system_zoom_state_valid || !FleetLabelThresholdEnabled()) {
-    threshold_state_valid = false;
-    return;
-  }
-
-  const auto &config                    = Config::Get();
-  const auto  player_uses_threshold     = config.zoom_label_player.detail == FleetLabelDetail::Threshold;
-  const auto  non_player_uses_threshold = config.zoom_label_non_player.detail == FleetLabelDetail::Threshold;
-  const auto  player_expanded =
-      player_uses_threshold && FleetLabelsExpandedAt(system_normalized_zoom, config.zoom_label_player.zoom_threshold);
-  const auto non_player_expanded =
-      non_player_uses_threshold
-      && FleetLabelsExpandedAt(system_normalized_zoom, config.zoom_label_non_player.zoom_threshold);
-  if (threshold_state_valid && (!player_uses_threshold || player_expanded == player_threshold_state_expanded)
-      && (!non_player_uses_threshold || non_player_expanded == non_player_threshold_state_expanded)) {
-    return;
+  auto&      config    = Config::Get();
+  const bool shortcuts = config.control.hotkeys_enabled && !config.control.use_scopely_hotkeys;
+
+  float target      = 0.0f;
+  bool  from_preset = false;
+  if (shortcuts) {
+    for (const auto& preset : kPresets) {
+      if (Shortcut::IsDown(preset.store)) {
+        StorePreset(preset.label, config.graphics.*preset.value, zoom);
+        return false;
+      }
+    }
+    if (Shortcut::IsDown(Action::kSetZoomDefault)) {
+      StorePreset("System Default", config.graphics.default_system_zoom, zoom);
+      return false;
+    }
+    for (const auto& preset : kPresets) {
+      if (Shortcut::IsDown(preset.go)) {
+        target      = config.graphics.*preset.value;
+        from_preset = true;
+        break;
+      }
+    }
+    if (config.control.hotkeys_extended) {
+      if (Shortcut::IsDown(Action::kZoomReset))
+        target = config.graphics.default_system_zoom;
+      else if (Shortcut::IsDown(Action::kZoomMin))
+        target = config.graphics.zoom;
+      else if (Shortcut::IsDown(Action::kZoomMax))
+        target = 100.0f;
+    }
   }
-
-  threshold_state_valid               = true;
-  player_threshold_state_expanded     = player_expanded;
-  non_player_threshold_state_expanded = non_player_expanded;
-  ApplyAllFleetLabelDetails();
-
-#ifdef _MODDBG
-  spdlog::info("Fleet label detail threshold state updated at normalized zoom {:.4f}", system_normalized_zoom);
-#endif
-}
-} // namespace
-
-vec3 GetMouseWorldPos(Camera *cam, vec3 *pos)
-{
-  using MathUtils = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.Client.Core", "MathUtils">;
-
-  if (cam == nullptr || pos == nullptr) {
-    return {0.0f, 0.0f, 0.0f};
+  if (target != 0.0f) {
+    ZoomAtMouse(zoom, target, true);
+  } else {
+    const float step = config.graphics.keyboard_zoom_speed * unity::Time::deltaTime();
+    if (shortcuts && Shortcut::IsPressed(Action::kZoomIn))
+      ZoomAtMouse(zoom, step, false);
+    else if (shortcuts && Shortcut::IsPressed(Action::kZoomOut))
+      ZoomAtMouse(zoom, -step, false);
   }
 
-  return MathUtils::Call<"GetMouseWorldPos", vec3>(cam, *pos);
-}
-
-auto do_default_zoom = false;
-
-inline void StoreZoom(std::string label, float &zoom, NavigationZoom *_this)
-{
-  auto old_zoom = zoom;
-  zoom          = (_this->Distance() - _this->minimum()) / (_this->maximum() - _this->minimum()) * Config::Get().zoom;
-  spdlog::info("Changing {} from {} to {}", label, old_zoom, zoom);
+  // With use_presets_as_default, jumping to a preset also makes it the zoom used on entering a system.
+  if (from_preset && target > 0.0f && config.graphics.use_presets_as_default)
+    StorePreset("System Preset Default from Preset", config.graphics.default_system_zoom, zoom);
+  return true;
 }
 
-static float s_expectedScale = 0;
-
-static void ApplySystemZoomRange(NavigationZoom *_this, float radius)
+void NavigationZoom_Update_Hook(auto original, NavigationZoom* _this)
 {
-  if (!_this || radius <= 0.0f) {
+  unity::Key::Poll();
+  FleetLabelsFollowDepth(_this, _this->depth());
+  KeepZoomRange(_this);
+
+  // The jump on entering a system is not keyboard input, so it happens even while a text field has focus.
+  bool run_game_update = true;
+  if (std::exchange(zoom_to_default, false))
+    ZoomAtMouse(_this, Config::Get().graphics.default_system_zoom, true);
+  else if (!unity::Key::IsInputFocused())
+    run_game_update = KeyboardZoom(_this);
+  if (!run_game_update)
     return;
-  }
 
-  auto ratio = (Config::Get().zoom / radius);
-  _this->SetFarRatioSystemNormal(0.55f * ratio);
-  _this->SetFarRatioSystemExtended(ratio);
+  original(_this);
+  KeepZoomRange(_this);
+  FleetLabelsAfterZoom(_this);
 }
 
-static void SetSceneCameraFarClip(NavigationZoom *_this)
+// Entering a system: widen the range before and after the game sets it up, and zoom to the default next update.
+template <typename Original, typename... Args>
+void EnterDepth(Original original, NavigationZoom* zoom, NodeDepth depth, float radius, Args... args)
 {
-  if (!_this) {
-    return;
-  }
-
-  auto *cam = _this->sceneCamera();
-  if (!cam) {
-    return;
-  }
-
-  cam->SetFarClipPlane(Config::Get().zoom * 3.75f);
-  cam->SetClearFlags(2);
-  cam->SetBackgroundColor({0, 0, 0, 0});
+  FleetLabelsFollowDepth(zoom, depth);
+  if (depth != NodeDepth::SolarSystem)
+    return original(zoom, args...);
+  ApplyZoomRange(zoom, radius);
+  original(zoom, args...);
+  ApplyZoomRange(zoom, 0.0f);
+  zoom_to_default = true;
 }
 
-static void EnsureSystemZoomRange(NavigationZoom *_this)
-{
-  if (!_this || _this->depth() != NodeDepth::SolarSystem) {
-    return;
-  }
+void NavigationZoom_SetViewParameters_Hook(auto original, NavigationZoom* _this, float radius, NodeDepth depth)
+{ EnterDepth(original, _this, depth, radius, radius, depth); }
 
-  const auto max_zoom = Config::Get().zoom;
-  if (max_zoom <= 0.0f) {
-    return;
-  }
+void NavigationZoom_SetDepth_Hook(auto original, NavigationZoom* _this, NodeDepth depth)
+{ EnterDepth(original, _this, depth, _this->viewRadius(), depth); }
 
-  ApplySystemZoomRange(_this, _this->viewRadius());
-  if (_this->maximum() < max_zoom) {
-    _this->SetMaximum(max_zoom);
-  }
-
-  const auto zoom_total = _this->maximum() - _this->minimum();
-  if (zoom_total > 0.0f) {
-    _this->SetZoomtotal(zoom_total);
-  }
-
-  SetSceneCameraFarClip(_this);
-}
-
-static void ScaleFR(il2cpp::Object *fr)
+// Planet flat renderables (the 2D planet sprites) are scaled by fr_scale. The game reuses them and asks for them on
+// every zoom, so each transform remembers the size it was scaled to and is left alone while it still has it.
+// Planets differ in base size, so this is per transform: one shared value made two planets rescale each other.
+void ScaleFlatRenderable(unity::Component* renderable)
 {
-  if (!fr) {
-    return;
-  }
-
-  float factor = Config::Get().fr_scale;
-  if (factor <= 0.0f || factor == 1.0f) {
-    return;
-  }
-
-  // FlatRenderable is a Component; transform resolves on its runtime class.
-  auto *t = fr->Get<"transform", Transform *>();
-  if (t == nullptr) {
+  // A system has a handful of planets; past this, entries from earlier systems are dropped.
+  constexpr size_t                                    kRemembered = 256;
+  static std::unordered_map<unity::Transform*, float> scaled;
+  const float                                         factor = Config::Get().graphics.fr_scale;
+  auto* transform = renderable && factor > 0.0f && factor != 1.0f ? renderable->transform() : nullptr;
+  if (!transform)
     return;
-  }
-
-  auto scale = t->localScale();
-  if (s_expectedScale > 0 && fabsf(scale.x - s_expectedScale) < 0.1f) {
+  const auto scale = transform->localScale();
+  if (const auto it = scaled.find(transform); it != scaled.end() && std::fabs(scale.x - it->second) < 0.1f)
     return;
-  }
-
-  Vector3 newScale = {scale.x * factor, scale.y * factor, scale.z * factor};
-  t->SetLocalScale(newScale);
-  s_expectedScale  = newScale.x;
-}
-
-void NavigationZoom_Update_Hook(auto original, NavigationZoom *_this)
-{
-  static auto GetMousePosition =
-      il2cpp::ResolveICall<void(vec3 *)>("UnityEngine.Input::get_mousePosition_Injected(UnityEngine.Vector3&)");
-  static auto GetDeltaTime = il2cpp::ResolveICall<float()>("UnityEngine.Time::get_deltaTime()");
-
-  if (fleet_label_hooks_installed) {
-    const auto zoom_id = reinterpret_cast<uintptr_t>(_this);
-    if (_this->depth() == NodeDepth::SolarSystem) {
-      BeginFleetLabelSystemState(_this);
-    } else if (active_system_zoom_id == zoom_id) {
-      ResetFleetLabelSystemState();
-    }
-  }
-
-  const auto dt               = GetDeltaTime();
-  auto       zoomDelta        = 0.0f;
-  bool       do_absolute_zoom = false;
-  bool       do_store_zoom    = false;
-  auto       config           = &Config::Get();
-
-  EnsureSystemZoomRange(_this);
-
-  const auto camera_shortcuts_enabled = config->hotkeys_enabled && !config->use_scopely_hotkeys;
-
-  if (!Key::IsInputFocused()) {
-    if (camera_shortcuts_enabled) {
-      if (MapKey::IsDown(GameFunction::SetZoomPreset1)) {
-        return StoreZoom("System Preset 1", config->system_zoom_preset_1, _this);
-      } else if (MapKey::IsDown(GameFunction::SetZoomPreset2)) {
-        return StoreZoom("System Preset 2", config->system_zoom_preset_2, _this);
-      } else if (MapKey::IsDown(GameFunction::SetZoomPreset3)) {
-        return StoreZoom("System Preset 3", config->system_zoom_preset_3, _this);
-      } else if (MapKey::IsDown(GameFunction::SetZoomPreset4)) {
-        return StoreZoom("System Preset 4", config->system_zoom_preset_4, _this);
-      } else if (MapKey::IsDown(GameFunction::SetZoomPreset5)) {
-        return StoreZoom("System Preset 5", config->system_zoom_preset_5, _this);
-      } else if (MapKey::IsDown(GameFunction::SetZoomDefault)) {
-        return StoreZoom("System Default", config->default_system_zoom, _this);
-      }
-
-      do_absolute_zoom = true;
-      if (MapKey::IsDown(GameFunction::ZoomPreset1)) {
-        zoomDelta     = config->system_zoom_preset_1;
-        do_store_zoom = true;
-      } else if (MapKey::IsDown(GameFunction::ZoomPreset2)) {
-        zoomDelta     = config->system_zoom_preset_2;
-        do_store_zoom = true;
-      } else if (MapKey::IsDown(GameFunction::ZoomPreset3)) {
-        zoomDelta     = config->system_zoom_preset_3;
-        do_store_zoom = true;
-      } else if (MapKey::IsDown(GameFunction::ZoomPreset4)) {
-        zoomDelta     = config->system_zoom_preset_4;
-        do_store_zoom = true;
-      } else if (MapKey::IsDown(GameFunction::ZoomPreset5)) {
-        zoomDelta     = config->system_zoom_preset_5;
-        do_store_zoom = true;
-      }
-
-      if (config->hotkeys_extended) {
-        if (MapKey::IsDown(GameFunction::ZoomReset)) {
-          do_absolute_zoom = false;
-          do_default_zoom  = true;
-        } else if (MapKey::IsDown(GameFunction::ZoomMin)) {
-          zoomDelta = config->zoom;
-        } else if (MapKey::IsDown(GameFunction::ZoomMax)) {
-          zoomDelta = 100;
-        }
-      }
-    }
-
-    if (do_default_zoom) {
-      do_absolute_zoom = true;
-      zoomDelta        = config->default_system_zoom;
-    }
-
-    if (zoomDelta == 0.0f) {
-      do_absolute_zoom = false;
-      zoomDelta        = config->keyboard_zoom_speed * dt;
-    }
-
-    if ((camera_shortcuts_enabled && MapKey::IsPressed(GameFunction::ZoomIn)) || do_absolute_zoom) {
-      vec3 mousePos;
-      GetMousePosition(&mousePos);
-      _this->SetZoomLocation(vec2{.x = mousePos.x, .y = mousePos.y});
-      if (do_absolute_zoom) {
-        auto zoom_distance = _this->minimum() + (_this->maximum() - _this->minimum()) * (zoomDelta / config->zoom);
-        _this->SetDistance(zoom_distance);
-      } else {
-        _this->SetZoomDelta(zoomDelta);
-        _this->SetLastZoomDelta(zoomDelta);
-      }
-      _this->SetWorldPoint(GetMouseWorldPos(_this->sceneCamera(), &mousePos));
-      _this->ZoomCameraAtWorldPoint();
-    } else if (camera_shortcuts_enabled && MapKey::IsPressed(GameFunction::ZoomOut)) {
-      vec3 mousePos;
-      GetMousePosition(&mousePos);
-      _this->SetZoomLocation(vec2{.x = mousePos.x, .y = mousePos.y});
-      _this->SetZoomDelta(-1.0f * zoomDelta);
-      _this->SetLastZoomDelta(-1.0f * zoomDelta);
-      _this->SetWorldPoint(GetMouseWorldPos(_this->sceneCamera(), &mousePos));
-      _this->ZoomCameraAtWorldPoint();
-    }
-  }
-
-  if (zoomDelta > 0.0f && config->use_presets_as_default && do_store_zoom) {
-    StoreZoom("System Preset Default from Preset", config->default_system_zoom, _this);
-  }
-
-  do_default_zoom = false;
-
-  original(_this);
-
-  EnsureSystemZoomRange(_this);
-  if (fleet_label_hooks_installed && _this->depth() == NodeDepth::SolarSystem) {
-    BeginFleetLabelSystemState(_this);
-    const auto state_was_valid   = system_zoom_state_valid;
-    const auto threshold_enabled = FleetLabelThresholdEnabled();
-    system_zoom_level            = _this->zoomLevel();
-    if (threshold_enabled) {
-      system_normalized_zoom = _this->NormalizedZoom();
-    }
-    system_zoom_state_valid = true;
-    if (threshold_enabled) {
-      UpdateFleetLabelThreshold();
-    } else if (!state_was_valid) {
-      ApplyAllFleetLabelDetails();
-    }
-  }
+  if (scaled.size() >= kRemembered)
+    scaled.clear();
+  transform->SetLocalScale({scale.x * factor, scale.y * factor, scale.z * factor});
+  scaled.insert_or_assign(transform, scale.x * factor);
 }
 
-void NavigationLOD_UpdateLOD_Hook(auto original, NavigationLOD *_this, ZoomLevels level)
+unity::Component* PlanetViewUtils_get_FlatRenderable_Hook(auto original, PlanetViewUtils* _this)
 {
-  const auto *profile         = FleetLabelProfileFor(_this);
-  const auto  effective_level = profile != nullptr ? FleetLabelZoomLevel(level, *profile) : level;
-  if (profile != nullptr) {
-    _this->SetTargetLevel(effective_level);
-  }
-  original(_this, effective_level);
-  if (profile != nullptr) {
-    _this->SetTargetLevel(effective_level);
-  }
+  auto* renderable = original(_this);
+  ScaleFlatRenderable(renderable);
+  return renderable;
 }
 
-void NavigationFleetWidget_OnEnable_Hook(auto original, NavigationFleetWidget *_this)
+// The game mostly reads the renderable field directly; asking through the getter routes it via the hook above.
+void PlanetViewUtils_CameraZoomedEventHandler_Hook(auto original, PlanetViewUtils* _this, float distance,
+                                                   float normalized)
 {
-  original(_this);
-  if (!_this) {
-    return;
-  }
-
-  // Fresh pooled widgets are enabled before BindDataContext assigns m_context. Forcing an LOD in that window can fire
-  // OnLODChanged callbacks that dereference the not-yet-bound fleet data.
-  if (_this->Context() == nullptr) {
-    return;
-  }
-
-  auto *lod = _this->lod();
-  if (lod) {
-    fleet_label_widgets.insert_or_assign(lod, _this);
-    if (FleetLabelThresholdEnabled() && !system_zoom_state_valid) {
-      threshold_state_valid = false;
-    }
-    ApplyFleetLabelDetail(lod, system_zoom_level);
-  }
+  original(_this, distance, normalized);
+  if (_this)
+    _this->FlatRenderable();
 }
 
-void NavigationFleetWidget_OnDisable_Hook(auto original, NavigationFleetWidget *_this)
-{
-  if (_this) {
-    auto *lod = _this->lod();
-    fleet_label_widgets.erase(lod);
-    if (_this->Context() != nullptr) {
-      RestoreNativeFleetLabelDetail(lod);
-    }
-  }
-  original(_this);
-}
+// --- Panning and rotation ---
 
-void NavigationFleetWidget_OnDidBindContext_Hook(auto original, NavigationFleetWidget *_this)
+// Whether the mod, not the game, moves the camera with the Move* shortcuts.
+bool ModMovesCamera()
 {
-  original(_this);
-  if (_this == nullptr) {
-    return;
-  }
-
-  auto *lod = _this->lod();
-  if (lod != nullptr) {
-    fleet_label_widgets.insert_or_assign(lod, _this);
-    ApplyFleetLabelDetail(lod, system_zoom_level);
-  }
+  const auto& config = Config::Get();
+  return config.control.hotkeys_enabled && !config.control.use_scopely_hotkeys && !config.ui.disable_move_keys;
 }
 
-void NavigationFleetWidget_OnAboutToReleaseContext_Hook(auto original, NavigationFleetWidget *_this)
-{
-  if (_this != nullptr) {
-    auto *lod = _this->lod();
-    if (lod != nullptr) {
-      fleet_label_widgets.erase(lod);
-      if (_this->Context() != nullptr) {
-        RestoreNativeFleetLabelDetail(lod);
-      }
-    }
-  }
-  original(_this);
-}
+bool PointerHeld()
+{ return unity::Input::GetMouseButton(0) || unity::Input::touchCount() > 0; }
 
-void PlanetViewUtils_CameraZoomedEventHandler_Hook(auto original, PlanetViewUtils *_this, float zoomDistance,
-                                                   float normalizedZoom)
+// The game's own tutorial and modal/text-input gates for keyboard panning.
+bool KeyboardPanAllowed()
 {
-  original(_this, zoomDistance, normalizedZoom);
-
-  if (_this != nullptr) {
-    _this->GetFlatRenderable(); // probe: triggers get_FlatRenderable_Hook, which scales the FR; game often reads the
-                                // field directly so our detour needs this call-path
-  }
+  auto* manager = Hub::Tutorial();
+  return manager && manager->IsSceneInputAllowed() && ShortcutsManager::CanUseShortcuts()
+         && !unity::Key::IsInputFocused();
 }
 
-void NavigationZoom_SetViewParameters_Hook(auto original, NavigationZoom *_this, float radius, NodeDepth depth)
+// Replaces the game's LateUpdate: the keyboard source is the mod's shortcuts, and the pan keeps gliding after the
+// drag or key is released. Each frame moves the camera once: by the keys while one is held, otherwise by the
+// glide.
+bool NavigationPan_LateUpdate_Hook(auto original, NavigationPan* _this)
 {
-  if (fleet_label_hooks_installed && depth != NodeDepth::SolarSystem) {
-    if (active_system_zoom_id == reinterpret_cast<uintptr_t>(_this)) {
-      ResetFleetLabelSystemState();
+  unity::Key::Poll();
+  const auto& config                     = Config::Get();
+  const bool  disable_target_camera_lock = config.graphics.disable_target_camera_lock;
+  // Dropping the tracked target before either pan path runs lets the player pan away from it.
+  if (disable_target_camera_lock && _this->trackingPOI())
+    _this->SetTrackingPOI(nullptr);
+  // An arrow held for a CTRL-arrow style shortcut must not pan as well, natively or through the mod.
+  const bool arrow_owned = Shortcut::Owns(unity::KeyCode::LeftArrow) || Shortcut::Owns(unity::KeyCode::RightArrow)
+                           || Shortcut::Owns(unity::KeyCode::UpArrow) || Shortcut::Owns(unity::KeyCode::DownArrow);
+  const bool keyboard    = config.control.hotkeys_enabled && !config.ui.disable_move_keys && !arrow_owned;
+
+  // With the game's own hotkeys, its LateUpdate pans and glides by itself. The mod still applies its momentum falloff
+  // to that glide, without moving the camera a second time.
+  const bool native = keyboard && (config.control.use_scopely_hotkeys || !config.patches.hotkeyhooks);
+  if (native)
+    original(_this);
+
+  auto       d       = _this->lastDelta();
+  const bool blocked = _this->BlockPan() || (_this->trackingPOI() && !disable_target_camera_lock);
+  // The native recognizer owns held-drag movement, including when the legacy Input API does not report the pointer.
+  // Never replay its delta as momentum.
+  const bool pointer = PointerHeld() || _this->panningStarted();
+  bool       by_keys = false;
+  if (keyboard && !native && !blocked && !pointer && KeyboardPanAllowed()) {
+    // Opposite bindings cancel; normalize diagonals like the native 2D composite.
+    const float x = float(Shortcut::IsPressed(Action::kMoveRight)) - float(Shortcut::IsPressed(Action::kMoveLeft));
+    const float y = float(Shortcut::IsPressed(Action::kMoveUp)) - float(Shortcut::IsPressed(Action::kMoveDown));
+    if (const float length = std::sqrt(x * x + y * y); length > 0.0f) {
+      d.x     = -x / length * _this->keyboardDeltaScaler();
+      d.y     = -y / length * _this->keyboardDeltaScaler();
+      by_keys = true;
+      _this->MoveCamera(unity::Vector2{d.x * _this->deltaScaler(), d.y * _this->deltaScaler()}, true);
     }
-  } else if (fleet_label_hooks_installed) {
-    BeginFleetLabelSystemState(_this);
   }
 
-  if (depth == NodeDepth::SolarSystem) {
-    ApplySystemZoomRange(_this, radius);
-    SetSceneCameraFarClip(_this);
-
-    original(_this, radius, depth);
-
-    SetSceneCameraFarClip(_this);
-    do_default_zoom = true;
-  } else {
-    original(_this, radius, depth);
+  if (blocked) {
+    d = {};
+  } else if (!by_keys && !pointer) {
+    const auto falloff = config.graphics.system_pan_momentum_falloff;
+    d.x *= falloff;
+    d.y *= falloff;
+    if (!native)
+      _this->MoveCamera(unity::Vector2{d.x, d.y}, true);
   }
+  _this->SetLastDelta(d);
+  _this->SetFarMagRadiusRatioSystemExtended(_this->farMagRadiusRatioSystemNormal());
+  return true;
 }
 
-void NavigationZoom_SetDepth_Hook(auto original, NavigationZoom *_this, NodeDepth depth)
+// Move left and right rotate the camera around the station.
+void OrbitFrameProvider_UpdateInputData_Hook(auto original, OrbitFrameProvider* _this, unity::Camera* primary_camera)
 {
-  if (fleet_label_hooks_installed && depth != NodeDepth::SolarSystem) {
-    if (active_system_zoom_id == reinterpret_cast<uintptr_t>(_this)) {
-      ResetFleetLabelSystemState();
-    }
-  } else if (fleet_label_hooks_installed) {
-    BeginFleetLabelSystemState(_this);
-  }
+  original(_this, primary_camera);
+  unity::Key::Poll();
 
-  if (depth == NodeDepth::SolarSystem) {
-    ApplySystemZoomRange(_this, _this->viewRadius());
-    SetSceneCameraFarClip(_this);
-
-    original(_this, depth);
+  auto* sections = Hub::Sections();
+  if (!ModMovesCamera() || !sections || sections->CurrentSection() != SectionID::Starbase_Exterior
+      || unity::Key::IsInputFocused())
+    return;
 
-    SetSceneCameraFarClip(_this);
-    do_default_zoom = true;
-  } else {
-    original(_this, depth);
-  }
+  constexpr float kDegreesPerSecond = 45.0f;
+  const float     step              = kDegreesPerSecond * unity::Time::deltaTime();
+  if (Shortcut::IsPressed(Action::kMoveLeft))
+    _this->SetRotationAngleDelta(_this->RotationAngleDelta() - step);
+  if (Shortcut::IsPressed(Action::kMoveRight))
+    _this->SetRotationAngleDelta(_this->RotationAngleDelta() + step);
 }
 
-void *PlanetViewUtils_get_FlatRenderable_Hook(auto original, PlanetViewUtils *_this)
+// A held touch reports Stationary, which the game's pan ignores; report it as moving so drags keep panning.
+TKTouch* TKTouch_populateWithPosition_Hook(auto original, TKTouch* _this, uintptr_t pos, unity::TouchPhase phase)
 {
-  auto *fr = original(_this);
-  if (!fr) {
-    return fr;
-  }
-
-  ScaleFR(static_cast<il2cpp::Object *>(fr));
-  return fr;
+  auto* touch = original(_this, pos, phase);
+  if (touch && touch->phase() == unity::TouchPhase::Stationary)
+    touch->SetPhase(unity::TouchPhase::Moved);
+  return touch;
 }
 
-void InstallZoomHooks()
+void InstallZoom()
 {
-  auto update = NavigationZoom::Class::Method("Update");
-
-  if (FleetLabelProfilesEnabled()) {
-    // Installed as a set. Missing fields and properties (_lod, Context, FleetType) read as null or zero, which the hooks
-    // treat as native labels, so only the methods gate installation.
-    auto update_lod                  = NavigationLOD::Class::Method("UpdateLOD");
-    auto on_enable                   = NavigationFleetWidget::Class::Method("OnEnable");
-    auto on_disable                  = NavigationFleetWidget::Class::Method("OnDisable");
-    auto on_did_bind_context         = NavigationFleetWidget::Class::Method("OnDidBindContext");
-    auto on_about_to_release_context = NavigationFleetWidget::Class::Method("OnAboutToReleaseContext");
-
-    if (update && update_lod && on_enable && on_disable && on_did_bind_context && on_about_to_release_context) {
-      fleet_label_hooks_installed = true;
-      SPUD_STATIC_DETOUR(update_lod.Pointer(), NavigationLOD_UpdateLOD_Hook);
-      SPUD_STATIC_DETOUR(on_enable.Pointer(), NavigationFleetWidget_OnEnable_Hook);
-      SPUD_STATIC_DETOUR(on_disable.Pointer(), NavigationFleetWidget_OnDisable_Hook);
-      SPUD_STATIC_DETOUR(on_did_bind_context.Pointer(), NavigationFleetWidget_OnDidBindContext_Hook);
-      SPUD_STATIC_DETOUR(on_about_to_release_context.Pointer(), NavigationFleetWidget_OnAboutToReleaseContext_Hook);
-    } else {
-      spdlog::error("Fleet label detail hooks were not installed; using native fleet labels");
-    }
-  }
-
-  if (auto method = PlanetViewUtils::Class::Method("CameraZoomedEventHandler"))
-    SPUD_STATIC_DETOUR(method.Pointer(), PlanetViewUtils_CameraZoomedEventHandler_Hook);
-  if (auto method = PlanetViewUtils::Class::Method("get_FlatRenderable"))
-    SPUD_STATIC_DETOUR(method.Pointer(), PlanetViewUtils_get_FlatRenderable_Hook);
-
-  if (update)
-    SPUD_STATIC_DETOUR(update.Pointer(), NavigationZoom_Update_Hook);
-
+  IL2CPP_HOOK(PlanetViewUtils::Class::Method("CameraZoomedEventHandler"),
+              PlanetViewUtils_CameraZoomedEventHandler_Hook);
+  IL2CPP_HOOK(PlanetViewUtils::Class::Method("get_FlatRenderable"), PlanetViewUtils_get_FlatRenderable_Hook);
+  IL2CPP_HOOK(NavigationZoom::Class::Method("Update"), NavigationZoom_Update_Hook);
+  // TODO: SetDepth has only ever been detoured on Windows and the reason was not recorded; check its prologue
+  // against SPUD's overwrite size before enabling it on macOS.
 #if _WIN32
-  if (auto method = NavigationZoom::Class::Method("SetDepth"))
-    SPUD_STATIC_DETOUR(method.Pointer(), NavigationZoom_SetDepth_Hook);
+  IL2CPP_HOOK(NavigationZoom::Class::Method("SetDepth"), NavigationZoom_SetDepth_Hook);
 #endif
+  IL2CPP_HOOK(NavigationZoom::Class::Method("SetViewParameters"), NavigationZoom_SetViewParameters_Hook);
+}
 
-  if (auto method = NavigationZoom::Class::Method("SetViewParameters"))
-    SPUD_STATIC_DETOUR(method.Pointer(), NavigationZoom_SetViewParameters_Hook);
+void InstallPan()
+{
+  IL2CPP_HOOK(OrbitFrameProvider::Class::Method("UpdateInputData"), OrbitFrameProvider_UpdateInputData_Hook);
+  IL2CPP_HOOK(TKTouch::Class::Method("populateWithPosition"), TKTouch_populateWithPosition_Hook);
+  IL2CPP_HOOK(NavigationPan::Class::Method("LateUpdate"), NavigationPan_LateUpdate_Hook);
 }
+} // namespace
+
+const Feature kZoom{"Zoom", &Config::Patches::zoomhooks, InstallZoom};
+const Feature kPan{"Pan", &Config::Patches::panhooks, InstallPan};
diff --git a/mods/src/patches/patches.cc b/mods/src/patches/patches.cc
index 05a5a815d..7c9d12c8a 100644
--- a/mods/src/patches/patches.cc
+++ b/mods/src/patches/patches.cc
@@ -1,88 +1,151 @@
-#include <filesystem>
-#include "patches.h"
+#include "mod.h"
+
+#include "config.h"
+#include "patches/patches.h"
 #include "file.h"
 #include "version.h"
 
-#include <il2cpp/il2cpp.h>
-
-#include <spud/detour.h>
+#include "prime/ui.h"
 
+#include <il2cpp/hook.h>
+#include <il2cpp/il2cpp.h>
 #include <spdlog/sinks/basic_file_sink.h>
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
+#include <unity/input.h>
+
+#include <filesystem>
+#include <iterator>
+#include <vector>
 
 #if _WIN32
 #include <Windows.h>
 #else
 #include <dlfcn.h>
 #include <libgen.h>
+#include <limits.h>
 #include <mach-o/dyld.h>
 #endif
 
-void InstallUiScaleHooks();
-void InstallZoomHooks();
-void InstallHavenZoomHooks();
-void InstallInteriorZoomHooks();
-void InstallBuffFixHooks();
-#if _WIN32
-void InstallFreeResizeHooks();
-#endif
-void InstallToastBannerHooks();
-void InstallPanHooks();
-void InstallHotkeyHooks();
-void InstallGiftsBulkClaimHooks();
-void InstallDailyFactionBulkClaimHooks();
-
-void InstallTestPatches();
-void InstallMiscPatches();
-void InstallMissionHudTweaksHooks();
-void InstallArtifactExchangeHooks();
-void InstallChatPatches();
-void InstallChatTitleDisplayHooks();
-void InstallTempCrashFixes();
-void InstallSyncPatches();
-void InstallObjectTrackers();
-void InstallLoadingScreenHooks();
-void InstallTransitionScreenHooks();
-void InstallGalacticAnomalyTimer();
-void InstallLoadingTipHooks();
-void InstallCargoFormatHooks();
-void InstallInstantCargoCounterHooks();
-void InstallOfficerSortHooks();
-void InstallPinnedShipSortHooks();
-void InstallPinnedShipClickHooks();
-void InstallDoubleClickAssignShipHooks();
-void InstallInstantWarpConfirmationHooks();
-void InstallForbiddenTechConfirmationHooks();
-void InstallForbiddenTechShipNameHooks();
-void InstallRevealConfirmationHooks();
-void InstallAudioEventHooks();
-void InstallActionQueueRecovery();
-void InstallThinQueueProtection();
-void InstallQueueAddressGuard();
-void InstallHavenHistoryHooks();
-void InstallAllianceGamesStoreHooks();
+// The mod's startup: StartMod hooks il2cpp_init, which sets up logging and settings, installs the features, and
+// installs the frame tick that runs them.
 
-__int64 il2cpp_init_hook(auto original, const char* domain_name)
+namespace
 {
-  struct PatchEntry {
-    const char*                  name;
-    std::pair<void (*)(), bool*> fnAndEnabled;
-  };
-
+// Installed in this order; the log numbers them.
+const Feature kLegacyHavenZoom{"HavenZoom", &Config::Patches::havenzoomhooks, InstallHavenZoomHooks};
+const Feature kLegacyHavenHistory{"HavenHistory", &Config::Patches::havenhistoryhooks, InstallHavenHistoryHooks};
+constexpr const Feature* kFeatures[] = {
+    &kInteriorZoom,
+    &kChatTitles,
+    &kRevealConfirm,
+    &kActionQueueRecovery,
+    &kQueueAddressGuard,
+    &kThinQueueProtection,
+    &kPinnedShipClick,
+    &kDockSelection,
+    &kAbilityButtons,
+    &kLegacyHavenZoom,
+    &kLegacyHavenHistory,
+    &kAllianceGamesStore,
+    &kUiScale,
+    &kZoom,
+    &kFleetLabels,
+    &kPan,
+    &kOutOfDockPower,
+    &kBuffCrashGuard,
+    &kToasts,
+    &kHotkeys,
+    &kGiftsAutoOpen,
+    &kDailyClaimFilter,
 #if _WIN32
-#ifndef NDEBUG
-  AllocConsole();
-  FILE* fp;
-  freopen_s(&fp, "CONOUT$", "w", stdout);
-#endif
+    &kFreeResize,
+    &kCursor,
 #endif
+    &kSkipRevealSequence,
+    &kGameConfigOverrides,
+    &kQueueSwitch,
+    &kShopLimits,
+    &kMissionHud,
+    &kArtifactExchange,
+    &kChat,
+    &kSync,
+    &kObjectTracker,
+    &kLoginScreen,
+    &kTransitionScreen,
+    &kAnomalyTimer,
+    &kLoadingTips,
+    &kInstantCargo,
+    &kCargoFormat,
+    &kOfficerSort,
+    &kPinnedShips,
+    &kDoubleClickAssign,
+    &kAssignOnEnter,
+    &kInstantWarp,
+    &kForbiddenTechConfirm,
+    &kForbiddenTechShipName,
+    &kAudio,
+};
+
+// The per-frame work of the installed features, in install order.
+std::vector<void (*)()> frame_work;
+
+// Runs one piece of frame work. An exception must not unwind into the game's native frame.
+void RunGuarded(void (*work)())
+{
+  try {
+    work();
+  } catch (const std::exception& error) {
+    spdlog::warn("[Frame] update failed: {}", error.what());
+  } catch (...) {
+    spdlog::warn("[Frame] update failed with an unknown exception");
+  }
+}
 
-  File::Init();
+// ScreenManager.Update is the mod's frame tick. It runs whatever hotkey mode is set: the settings file watch and
+// each feature's frame work first, then the shortcut dispatch. Returning without calling the game's Update swallows
+// the key, so the game's own handling of it does not run as well.
+void ScreenManager_Update_Hook(auto original, ScreenManager* _this)
+{
+  unity::Key::Poll();
+  RunGuarded(Config::ReloadIfChanged);
+  for (auto work : frame_work)
+    RunGuarded(work);
+  if (HandleShortcuts())
+    return;
+  original(_this);
+}
+
+void InstallFeatures(const Config& config)
+{
+  spdlog::info("Initializing code hooks:");
+  for (size_t i = 0; i < std::size(kFeatures); ++i) {
+    const auto& feature = *kFeatures[i];
+    const bool  enabled = !feature.group || config.patches.*feature.group;
+    spdlog::info(" {} {:>2} of {} ({})", enabled ? "+ Patching" : "x Skipping", i + 1, std::size(kFeatures),
+                 feature.name);
+    if (!enabled)
+      continue;
+    try {
+      if (feature.install)
+        feature.install();
+      if (feature.frame)
+        frame_work.push_back(feature.frame);
+    } catch (const std::exception& error) {
+      spdlog::error("{} failed to install: {}", feature.name, error.what());
+    }
+  }
+  // Last, so a feature never sees a frame before it is installed. Without the tick nothing polls, and the settings
+  // file is only read at startup.
+  if (!IL2CPP_HOOK(ScreenManager::Class::Method("Update"), ScreenManager_Update_Hook))
+    spdlog::error("The frame tick is missing: shortcuts, settings reload and per-frame features will not run");
+}
 
+void StartLogging()
+{
   std::string rotation_error;
   try {
-    const auto backup = [](int index) { return std::filesystem::path(std::string(File::Log()) + "." + std::to_string(index)); };
+    const auto backup = [](int index) { return std::filesystem::path(File::Log() + "." + std::to_string(index)); };
     std::filesystem::remove(backup(5));
     for (int index = 4; index >= 1; --index)
       if (std::filesystem::exists(backup(index)))
@@ -93,174 +156,122 @@ __int64 il2cpp_init_hook(auto original, const char* domain_name)
     rotation_error = error.what();
   }
   // Append if rotation failed so an existing session log is not truncated.
-  auto file_logger = spdlog::basic_logger_mt("default", File::Log(), false);
-  auto sink        = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-  file_logger->sinks().push_back(sink);
-  spdlog::set_default_logger(file_logger);
-
-  const auto log_level =
-      File::hasTrace() ? spdlog::level::trace : (File::hasDebug() ? spdlog::level::debug : spdlog::level::info);
+  auto logger = spdlog::basic_logger_mt("default", File::Log(), false);
+  logger->sinks().push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>());
+  spdlog::set_default_logger(logger);
 
-  spdlog::set_level(log_level);
-  spdlog::flush_on(log_level);
+  const auto level = File::Trace() ? spdlog::level::trace : File::Debug() ? spdlog::level::debug : spdlog::level::info;
+  spdlog::set_level(level);
+  spdlog::flush_on(level);
   if (!rotation_error.empty())
     spdlog::warn("Failed to rotate log history; preserving existing log: {}", rotation_error);
   il2cpp::SetErrorHandler([](std::string_view message) { spdlog::error("{}", message); });
+}
 
-#if VERSION_PATCH
-  if constexpr (sizeof(VERSION_COMMIT_HASH) > 1) {
+void LogBanner()
+{
+  if constexpr (VERSION_PATCH && sizeof(VERSION_COMMIT_HASH) > 1)
     spdlog::info("Initializing STFC Community Mod ({} [{}])", VER_PRODUCT_VERSION_STR, VERSION_COMMIT_HASH);
-  } else {
+  else
     spdlog::info("Initializing STFC Community Mod ({})", VER_PRODUCT_VERSION_STR);
-  }
-#else
-  spdlog::info("Initializing STFC Community Mod ({})", VER_PRODUCT_VERSION_STR);
-#endif
   spdlog::info("");
-  if (File::hasCustomNames()) {
-    spdlog::info("Using custom names");
-  } else {
-    spdlog::info("Using standard names");
-  }
-
+  spdlog::info("{}", File::Profile().empty() ? "Using standard names" : "Using custom names");
   spdlog::info("  Log: {}", File::Log());
   spdlog::info("  Cfg: {}", File::Config());
   spdlog::info("  Var: {}", File::Vars());
   spdlog::info("   BL: {}", File::Battles());
   spdlog::info("");
-
-#if VERSION_PATCH
-  spdlog::warn("*** NOTE: Beta versions may have unexpected bugs and issues");
-  spdlog::info("");
-#endif
-
+  if constexpr (VERSION_PATCH) {
+    spdlog::warn("*** NOTE: Beta versions may have unexpected bugs and issues");
+    spdlog::info("");
+  }
   spdlog::info("Please see https://github.com/STFC-Mod/mod for latest configuration help,");
   spdlog::info("examples and future releases, or visit the STFC Community Mod discord server");
   spdlog::info("at https://discord.gg/PrpHgs7Vjs");
   spdlog::info("");
   spdlog::info("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
   spdlog::info("");
-  spdlog::info("Loading Configuration...");
-  spdlog::info("");
-
-  static auto& cfg = Config::Get();
-
-  spdlog::info("");
-  spdlog::info("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
-  spdlog::info("");
+}
 
-  spdlog::info("Initializing code hooks:");
-  const PatchEntry patches[] = {
-      {"UiScaleHooks", {InstallUiScaleHooks, &cfg.installUiScaleHooks}},
-      {"ZoomHooks", {InstallZoomHooks, &cfg.installZoomHooks}},
-      {"HavenZoomHooks", {InstallHavenZoomHooks, &cfg.installHavenZoomHooks}},
-      {"InteriorZoomHooks", {InstallInteriorZoomHooks, &cfg.installInteriorZoomHooks}},
-      {"BuffFixHooks", {InstallBuffFixHooks, &cfg.installBuffFixHooks}},
-      {"ToastBannerHooks", {InstallToastBannerHooks, &cfg.installToastBannerHooks}},
-      {"PanHooks", {InstallPanHooks, &cfg.installPanHooks}},
-      {"HotkeyHooks", {InstallHotkeyHooks, &cfg.installHotkeyHooks}},
-      {"GiftsBulkClaimHooks", {InstallGiftsBulkClaimHooks, &cfg.installGiftsBulkClaimHooks}},
-      {"DailyFactionBulkClaimHooks", {InstallDailyFactionBulkClaimHooks, &cfg.installDailyFactionBulkClaimHooks}},
-#if _WIN32
-      {"FreeResizeHooks", {InstallFreeResizeHooks, &cfg.installFreeResizeHooks}},
+int64_t il2cpp_init_Hook(auto original, const char* domain_name)
+{
+#if _WIN32 && !defined(NDEBUG)
+  AllocConsole();
+  FILE* console;
+  freopen_s(&console, "CONOUT$", "w", stdout);
 #endif
-      {"TempCrashFixes", {InstallTempCrashFixes, &cfg.installTempCrashFixes}},
-      {"TestPatches", {InstallTestPatches, &cfg.installTestPatches}},
-      {"MiscPatches", {InstallMiscPatches, &cfg.installMiscPatches}},
-      {"MissionHudTweaksHooks", {InstallMissionHudTweaksHooks, &cfg.installMissionHudTweaksHooks}},
-      {"ArtifactExchangeHooks", {InstallArtifactExchangeHooks, &cfg.installArtifactExchangeHooks}},
-      {"ChatPatches", {InstallChatPatches, &cfg.installChatPatches}},
-      {"ChatTitleDisplay", {InstallChatTitleDisplayHooks, &cfg.installPlayerTitleDisplayHooks}},
-      {"SyncPatches", {InstallSyncPatches, &cfg.installSyncPatches}},
-      {"ObjectTracker", {InstallObjectTrackers, &cfg.installObjectTracker}},
-      {"LoadingScreen", {InstallLoadingScreenHooks, &cfg.installLoadingScreenHooks}},
-      {"TransitionScreen", {InstallTransitionScreenHooks, &cfg.installTransitionScreenHooks}},
-      {"GalacticAnomalyTimer", {InstallGalacticAnomalyTimer, &cfg.installGalacticAnomalyTimerHooks}},
-      {"LoadingTip", {InstallLoadingTipHooks, &cfg.installLoadingTipHooks}},
-      {"InstantCargoCounter", {InstallInstantCargoCounterHooks, &cfg.installInstantCargoCounterHooks}},
-      {"CargoFormat", {InstallCargoFormatHooks, &cfg.installCargoFormatHooks}},
-      {"OfficerSortHooks", {InstallOfficerSortHooks, &cfg.installOfficerSortHooks}},
-      {"PinnedShipSort", {InstallPinnedShipSortHooks, &cfg.installPinnedShipSortHooks}},
-      {"PinnedShipClick", {InstallPinnedShipClickHooks, &cfg.installPinnedShipClickToggle}},
-      {"DoubleClickAssignShip", {InstallDoubleClickAssignShipHooks, &cfg.installDoubleClickAssignShipHooks}},
-      {"InstantWarpConfirm", {InstallInstantWarpConfirmationHooks, &cfg.installInstantWarpConfirmationHooks}},
-      {"MessageBoxConfirmations", {InstallForbiddenTechConfirmationHooks, &cfg.installForbiddenTechConfirmationHooks}},
-      {"ForbiddenTechShipName", {InstallForbiddenTechShipNameHooks, &cfg.installForbiddenTechShipNameHooks}},
-      {"RevealConfirm", {InstallRevealConfirmationHooks, &cfg.installRevealConfirmationHooks}},
-      {"AudioEvents", {InstallAudioEventHooks, &cfg.installAudioEventHooks}},
-      {"ActionQueueRecovery", {InstallActionQueueRecovery, &cfg.installActionQueueRecoveryHooks}},
-      {"QueueAddressGuard", {InstallQueueAddressGuard, &cfg.installQueueAddressGuardHooks}},
-      {"ThinQueueProtection", {InstallThinQueueProtection, &cfg.installThinQueueProtectionHooks}},
-      {"HavenHistory", {InstallHavenHistoryHooks, &cfg.installHavenHistoryHooks}},
-      {"AllianceGamesStore", {InstallAllianceGamesStoreHooks, &cfg.installAllianceGamesStoreHooks}},
-  };
-  printf("il2cpp_init_hook(%s)\n", domain_name);
-
-  auto r = original(domain_name);
-
-  auto patch_count = 0;
-  auto patch_total = sizeof(patches) / sizeof(patches[0]);
 
-  for (const auto& patch : patches) {
-    patch_count++;
-    const auto [patch_func, patch_enabled] = patch.fnAndEnabled;
-    const auto patch_install               = (patch_enabled && *patch_enabled);
-    const auto patch_mode                  = patch_install ? "+ Patch" : "x Skipp";
-    spdlog::info(" {}ing {:>2} of {} ({})", patch_mode, patch_count, patch_total, patch.name);
-
-    if (patch_install) {
-      patch_func();
-    }
+  // Nothing here may throw into the game: a mod that cannot set itself up leaves the game running without it.
+  const Config* config = nullptr;
+  try {
+    File::Init();
+    StartLogging();
+    LogBanner();
+
+    spdlog::info("Loading Configuration...");
+    spdlog::info("");
+    config = &Config::Get();
+    spdlog::info("");
+    spdlog::info("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
+    spdlog::info("");
+  } catch (const std::exception& error) {
+    // The file logger may not exist; spdlog falls back to its console logger.
+    spdlog::error("Community mod setup failed, not installing any patches: {}", error.what());
   }
 
-  spdlog::info("");
+  // Bindings resolve against the runtime's metadata, so nothing is installed before the domain exists.
+  const auto result = original(domain_name);
+  if (!config)
+    return result;
 
-#if VERSION_PATCH
-  spdlog::info("Installed beta version {}.{}.{} (Patch {})", VERSION_MAJOR, VERSION_MINOR, VERSION_REVISION,
-               VERSION_PATCH);
-#else
-  spdlog::info("Installed release version {}.{}.{}", VERSION_MAJOR, VERSION_MINOR, VERSION_REVISION);
-#endif
+  InstallFeatures(*config);
 
+  spdlog::info("");
+  if constexpr (VERSION_PATCH)
+    spdlog::info("Installed beta version {}.{}.{} (Patch {})", VERSION_MAJOR, VERSION_MINOR, VERSION_REVISION,
+                 VERSION_PATCH);
+  else
+    spdlog::info("Installed release version {}.{}.{}", VERSION_MAJOR, VERSION_MINOR, VERSION_REVISION);
   spdlog::info("");
   spdlog::info("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
   spdlog::info("");
 
-  return r;
+  return result;
 }
+} // namespace
 
-void ApplyPatches()
+void StartMod()
 {
 #if _WIN32
   auto assembly = LoadLibraryA("GameAssembly.dll");
 #else
-  char     buf[PATH_MAX];
-  uint32_t bufsize = PATH_MAX;
-  _NSGetExecutablePath(buf, &bufsize);
-
+  char     executable[PATH_MAX];
+  uint32_t size = sizeof(executable);
+  if (_NSGetExecutablePath(executable, &size) != 0) {
+    fprintf(stderr, "stfc-community-mod: executable path does not fit\n");
+    return;
+  }
   char assembly_path[PATH_MAX];
-  snprintf(assembly_path, sizeof(assembly_path), "%s/%s", dirname(buf), "../Frameworks/GameAssembly.dylib");
-  printf("Loading %s\n", assembly_path);
+  snprintf(assembly_path, sizeof(assembly_path), "%s/../Frameworks/GameAssembly.dylib", dirname(executable));
   auto assembly = dlopen(assembly_path, RTLD_LAZY | RTLD_GLOBAL);
-
 #endif
 
-  if (assembly == nullptr) {
-    spdlog::error("Failed to load GameAssembly");
+  // The logger does not exist yet; it is set up inside il2cpp_init once the settings path is known.
+  if (!assembly) {
+    fprintf(stderr, "stfc-community-mod: failed to load GameAssembly\n");
     return;
-  } else {
-    try {
-      il2cpp::Initialize(assembly);
+  }
+
+  try {
+    il2cpp::Initialize(assembly);
 #if _WIN32
-      auto n = GetProcAddress(assembly, "il2cpp_init");
+    auto il2cpp_init = reinterpret_cast<void*>(GetProcAddress(assembly, "il2cpp_init"));
 #else
-      auto n = dlsym(assembly, "il2cpp_init");
+    auto il2cpp_init = dlsym(assembly, "il2cpp_init");
 #endif
-      printf("Got il2cpp_init %p\n", n);
-
-      SPUD_STATIC_DETOUR(n, il2cpp_init_hook);
-    } catch (const std::exception& error) {
-      spdlog::error("Failed to initialize IL2CPP hooks: {}", error.what());
-    }
+    if (!IL2CPP_DETOUR(il2cpp_init, il2cpp_init_Hook, "il2cpp_init"))
+      fprintf(stderr, "stfc-community-mod: failed to hook il2cpp_init\n");
+  } catch (const std::exception& error) {
+    fprintf(stderr, "stfc-community-mod: failed to hook il2cpp_init: %s\n", error.what());
   }
 }
diff --git a/mods/src/patches/patches.h b/mods/src/patches/patches.h
index 8a3f2c1c5..f4b23ddf1 100644
--- a/mods/src/patches/patches.h
+++ b/mods/src/patches/patches.h
@@ -1,3 +1,160 @@
 #pragma once
 
-void ApplyPatches();
+// The mod's features: the descriptors mod.cc installs, and the calls the shortcut dispatch in hotkeys.cc makes into
+// the features that own the work. Grouped by the file that defines them.
+
+#include "config.h"
+
+#include <cstdint>
+
+struct NavigationZoom;
+enum class NodeDepth : int32_t;
+
+// What mod.cc installs. Only the [patches] hook groups decide what is installed, so users can avoid clashing with
+// other mods; feature settings are read inside the hooks, which keeps every feature switchable at runtime.
+struct Feature {
+  const char* name;
+  // The [patches] group that installs it; null for the few that always install.
+  bool Config::Patches::* group;
+  // Null for frame work that needs no hooks.
+  void (*install)();
+  // Runs every frame from the frame tick once installed, in every hotkey mode, before the shortcuts. Returns at once
+  // when its feature is off.
+  void (*frame)() = nullptr;
+};
+
+// alliance_store.cc
+extern const Feature kAllianceGamesStore;
+
+// anomaly_timer.cc
+extern const Feature kAnomalyTimer;
+
+// audio.cc
+extern const Feature kAudio;
+
+// buffs.cc
+extern const Feature kOutOfDockPower;
+extern const Feature kBuffCrashGuard;
+
+// camera.cc
+extern const Feature kZoom;
+extern const Feature kPan;
+
+// cargo.cc
+extern const Feature kCargoFormat;
+extern const Feature kInstantCargo;
+
+// chat.cc
+extern const Feature kChat;
+// Opens chat, or focuses side chat's input. Never swallows the key.
+void OpenChatShortcut();
+// In chat, the channel shortcuts. True when the key was used.
+bool ChatChannelShortcuts();
+
+// dock.cc
+extern const Feature kPinnedShips;
+extern const Feature kDoubleClickAssign;
+extern const Feature kAssignOnEnter;
+
+// fleet_actions.cc
+extern const Feature kQueueSwitch;
+// The pre-scan cargo hooks; installed with the hotkeys.
+void InstallFleetActions();
+// A target or object viewer card is open in space.
+bool TargetViewerShown();
+// The number keys. True when the key was used.
+bool SelectShipShortcuts();
+// Select current and the queue switch. True when the key was used.
+bool FleetShortcuts();
+// The actions on the selected fleet and the open viewer. True when the key must not reach the game.
+bool FleetActionShortcuts();
+
+// fleet_labels.cc, fed by camera.cc's zoom hooks.
+extern const Feature kFleetLabels;
+void                 FleetLabelsFollowDepth(NavigationZoom* zoom, NodeDepth depth);
+void                 FleetLabelsAfterZoom(NavigationZoom* zoom);
+
+// forbidden_tech.cc
+extern const Feature kForbiddenTechConfirm;
+extern const Feature kForbiddenTechShipName;
+
+// game_config.cc
+extern const Feature kGameConfigOverrides;
+
+// hotkeys.cc
+extern const Feature kHotkeys;
+// The shortcut dispatch for one frame, run by the frame tick. True when the game's own ScreenManager.Update must
+// not run, so it does not handle the key as well. False until kHotkeys is installed.
+bool HandleShortcuts();
+
+// instant_warp.cc
+extern const Feature kInstantWarp;
+void                 CycleInstantWarpConfirmation();
+
+// keybind_badges.cc, installed with the hotkeys.
+void InstallKeybindBadges();
+// Toggles the game's keybind badges. False when the badges are not the mod's, so the key is not used.
+bool ToggleKeybindBadges();
+void HideKeybindBadges();
+
+// loading_screens.cc
+extern const Feature kLoginScreen;
+extern const Feature kTransitionScreen;
+extern const Feature kLoadingTips;
+
+// missions.cc
+extern const Feature kMissionHud;
+extern const Feature kDailyClaimFilter;
+
+// officers.cc
+extern const Feature kOfficerSort;
+
+// screens.cc
+// Presses a button a screen shortcut opened a screen for, once the screen is up. True when one was pressed.
+bool PressAwaitedButton();
+// The shortcuts that open, step through, or search game screens. True when the key must not reach the game.
+bool ScreenShortcuts();
+
+// shop.cc
+extern const Feature kGiftsAutoOpen;
+extern const Feature kShopLimits;
+extern const Feature kSkipRevealSequence;
+extern const Feature kArtifactExchange;
+
+// toasts.cc
+extern const Feature kToasts;
+
+// tracked_objects.cc
+extern const Feature kObjectTracker;
+
+// ui_scale.cc
+extern const Feature kUiScale;
+void                 AdjustUiScale(bool up);
+void                 AdjustUiShipScale(bool up);
+void                 AdjustUiViewerScale(bool up);
+
+// window.cc
+#if _WIN32
+extern const Feature kFreeResize;
+extern const Feature kCursor;
+#endif
+// The monitor's physical-to-logical pixel ratio on Windows; 1 elsewhere. Cached until `refresh`.
+float WindowDpiScale(bool refresh = false);
+
+// sync/sync.cc
+extern const Feature kSync;
+
+void InstallHavenZoomHooks();
+void InstallHavenHistoryHooks();
+
+
+
+extern const Feature kInteriorZoom;
+extern const Feature kChatTitles;
+extern const Feature kRevealConfirm;
+extern const Feature kActionQueueRecovery;
+extern const Feature kQueueAddressGuard;
+extern const Feature kThinQueueProtection;
+extern const Feature kPinnedShipClick;
+extern const Feature kDockSelection;
+extern const Feature kAbilityButtons;
diff --git a/mods/src/patches/screen_update_hook.cc b/mods/src/patches/screen_update_hook.cc
deleted file mode 100644
index 494fe77b0..000000000
--- a/mods/src/patches/screen_update_hook.cc
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "patches/screen_update_hook.h"
-
-#include <spdlog/spdlog.h>
-
-#include <algorithm>
-#include <exception>
-#include <vector>
-
-namespace
-{
-std::vector<ScreenManagerUpdateCallback> s_callbacks;
-bool                                     s_dispatching = false;
-} // namespace
-
-bool register_screen_manager_update_callback(ScreenManagerUpdateCallback callback)
-{
-  if (!callback) {
-    return false;
-  }
-  if (s_dispatching) {
-    spdlog::warn("[ScreenUpdate] rejected callback registration during dispatch");
-    return false;
-  }
-  if (std::find(s_callbacks.begin(), s_callbacks.end(), callback) != s_callbacks.end()) {
-    return true;
-  }
-  s_callbacks.push_back(callback);
-  return true;
-}
-
-void dispatch_screen_manager_update_callbacks()
-{
-  if (s_dispatching) {
-    spdlog::warn("[ScreenUpdate] suppressed recursive callback dispatch");
-    return;
-  }
-  s_dispatching = true;
-  for (const auto callback : s_callbacks) {
-    try {
-      callback();
-    } catch (const std::exception& error) {
-      spdlog::warn("[ScreenUpdate] callback failed: {}", error.what());
-    } catch (...) {
-      spdlog::warn("[ScreenUpdate] callback failed with an unknown exception");
-    }
-  }
-  s_dispatching = false;
-}
diff --git a/mods/src/patches/screen_update_hook.h b/mods/src/patches/screen_update_hook.h
deleted file mode 100644
index 613d5edee..000000000
--- a/mods/src/patches/screen_update_hook.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-// ScreenManager.Update has one detour owner shared by HotkeyHooks and opt-in frame services.
-// Installation is idempotent so either owner can request the dispatcher.
-bool install_screen_manager_update_hook();
-
-using ScreenManagerUpdateCallback = void (*)();
-
-// Registers a process-lifetime callback that runs before the game's ScreenManager.Update handling.
-// Register during patch installation. Re-registering the same callback is harmless.
-bool register_screen_manager_update_callback(ScreenManagerUpdateCallback callback);
-void dispatch_screen_manager_update_callbacks();
diff --git a/mods/src/patches/ship_shortcut_hint.h b/mods/src/patches/ship_shortcut_hint.h
index 671e74d54..e67b63a1b 100644
--- a/mods/src/patches/ship_shortcut_hint.h
+++ b/mods/src/patches/ship_shortcut_hint.h
@@ -1,22 +1,22 @@
 #pragma once
 
-#include "gamefunctions.h"
+#include "shortcuts.h"
 
 #include <cstddef>
 
 // Native ship actions identify FleetPlayerData::Index. Mod selection passes a position in FleetBarContext::FleetData
 // to RequestSelect instead; locked docks can leave gaps in the native indices.
 template <typename FleetIndexAt>
-GameFunction ShipShortcutHintAction(GameFunction native_action, std::size_t fleet_count, FleetIndexAt fleet_index_at)
+Action ShipShortcutHintAction(Action native_action, std::size_t fleet_count, FleetIndexAt fleet_index_at)
 {
-  if (native_action < GameFunction::SelectShip1 || native_action > GameFunction::SelectShip8)
+  if (native_action < Action::kSelectShip1 || native_action > Action::kSelectShip8)
     return native_action;
 
-  const auto     fleet_index    = native_action - GameFunction::SelectShip1;
-  constexpr auto shortcut_count = GameFunction::SelectShip8 - GameFunction::SelectShip1 + 1;
+  const auto     fleet_index    = static_cast<int>(native_action) - static_cast<int>(Action::kSelectShip1);
+  constexpr auto shortcut_count = static_cast<int>(Action::kSelectShip8) - static_cast<int>(Action::kSelectShip1) + 1;
   for (std::size_t position = 0; position < fleet_count && position < shortcut_count; ++position) {
     if (fleet_index_at(position) == fleet_index)
-      return static_cast<GameFunction>(GameFunction::SelectShip1 + position);
+      return static_cast<Action>(static_cast<int>(Action::kSelectShip1) + position);
   }
-  return GameFunction::Max;
+  return Action::kCount;
 }
diff --git a/mods/src/patches/shortcuts.cc b/mods/src/patches/shortcuts.cc
new file mode 100644
index 000000000..8256d3022
--- /dev/null
+++ b/mods/src/patches/shortcuts.cc
@@ -0,0 +1,525 @@
+#include "patches/shortcuts.h"
+
+#include "str_utils.h"
+
+#include <spdlog/spdlog.h>
+#include <unity/input.h>
+
+#include <algorithm>
+#include <array>
+#include <optional>
+
+namespace
+{
+// A key name from the settings file, and its keybind badge text when that differs from the name. The badge font
+// has few glyphs, so long names are shortened and the symbols the modifier notation uses are spelled out.
+struct KeyName {
+  std::string_view name;
+  unity::KeyCode   key;
+  std::string_view hint = {};
+};
+
+constexpr KeyName kKeys[] = {
+    {"END", unity::KeyCode::End},
+    {"HOME", unity::KeyCode::Home, "HM"},
+    {"PGDOWN", unity::KeyCode::PageDown, "PD"},
+    {"PGUP", unity::KeyCode::PageUp, "PU"},
+    {"DOWN", unity::KeyCode::DownArrow, "DN"},
+    {"LEFT", unity::KeyCode::LeftArrow, "LT"},
+    {"RIGHT", unity::KeyCode::RightArrow, "RT"},
+    {"UP", unity::KeyCode::UpArrow},
+    {"BACKSPACE", unity::KeyCode::Backspace, "BS"},
+    {"BREAK", unity::KeyCode::Break},
+    {"CAPS", unity::KeyCode::CapsLock},
+    {"CLEAR", unity::KeyCode::Clear},
+    {"DELETE", unity::KeyCode::Delete, "DEL"},
+    {"ESCAPE", unity::KeyCode::Escape, "ESC"},
+    {"HELP", unity::KeyCode::Help},
+    {"INSERT", unity::KeyCode::Insert},
+    {"MENU", unity::KeyCode::Menu},
+    {"PAUSE", unity::KeyCode::Pause},
+    {"PRINT", unity::KeyCode::Print},
+    {"RETURN", unity::KeyCode::Return, "ENT"},
+    {"SCROLL", unity::KeyCode::ScrollLock},
+    {"SYSREQ", unity::KeyCode::SysReq},
+    {"TAB", unity::KeyCode::Tab},
+    {"MOUSE0", unity::KeyCode::Mouse0, "M0"},
+    {"MOUSE1", unity::KeyCode::Mouse1, "M1"},
+    {"MOUSE2", unity::KeyCode::Mouse2, "M2"},
+    {"MOUSE3", unity::KeyCode::Mouse3, "M3"},
+    {"MOUSE4", unity::KeyCode::Mouse4, "M4"},
+    {"MOUSE5", unity::KeyCode::Mouse5, "M5"},
+    {"MOUSE6", unity::KeyCode::Mouse6, "M6"},
+    {"SPACE", unity::KeyCode::Space, "SPC"},
+    // Chords are split on '-', so the minus key needs a name.
+    {"MINUS", unity::KeyCode::Minus, "-"},
+    {"_", unity::KeyCode::Underscore},
+    {",", unity::KeyCode::Comma},
+    {";", unity::KeyCode::Semicolon},
+    {":", unity::KeyCode::Colon},
+    {"!", unity::KeyCode::Exclaim, "EXC"},
+    {"?", unity::KeyCode::Question},
+    {".", unity::KeyCode::Period},
+    {"'", unity::KeyCode::Quote},
+    {"(", unity::KeyCode::LeftParen},
+    {")", unity::KeyCode::RightParen},
+    {"[", unity::KeyCode::LeftBracket},
+    {"]", unity::KeyCode::RightBracket},
+    {"{", unity::KeyCode::LeftCurlyBracket},
+    {"}", unity::KeyCode::RightCurlyBracket},
+    {"@", unity::KeyCode::At},
+    {"*", unity::KeyCode::Asterisk},
+    {"/", unity::KeyCode::Slash},
+    {"\"", unity::KeyCode::DoubleQuote},
+    {"\\", unity::KeyCode::Backslash},
+    {"&", unity::KeyCode::Ampersand},
+    {"#", unity::KeyCode::Hash, "HSH"},
+    {"%", unity::KeyCode::Percent},
+    {"`", unity::KeyCode::BackQuote},
+    {"^", unity::KeyCode::Caret, "CAR"},
+    {"+", unity::KeyCode::Plus, "PLS"},
+    {"<", unity::KeyCode::Less},
+    {"=", unity::KeyCode::Equals},
+    {">", unity::KeyCode::Greater},
+    {"~", unity::KeyCode::Tilde},
+    {"$", unity::KeyCode::Dollar},
+    {"0", unity::KeyCode::Alpha0},
+    {"1", unity::KeyCode::Alpha1},
+    {"2", unity::KeyCode::Alpha2},
+    {"3", unity::KeyCode::Alpha3},
+    {"4", unity::KeyCode::Alpha4},
+    {"5", unity::KeyCode::Alpha5},
+    {"6", unity::KeyCode::Alpha6},
+    {"7", unity::KeyCode::Alpha7},
+    {"8", unity::KeyCode::Alpha8},
+    {"9", unity::KeyCode::Alpha9},
+    {"A", unity::KeyCode::A},
+    {"B", unity::KeyCode::B},
+    {"C", unity::KeyCode::C},
+    {"D", unity::KeyCode::D},
+    {"E", unity::KeyCode::E},
+    {"F", unity::KeyCode::F},
+    {"G", unity::KeyCode::G},
+    {"H", unity::KeyCode::H},
+    {"I", unity::KeyCode::I},
+    {"J", unity::KeyCode::J},
+    {"K", unity::KeyCode::K},
+    {"L", unity::KeyCode::L},
+    {"M", unity::KeyCode::M},
+    {"N", unity::KeyCode::N},
+    {"O", unity::KeyCode::O},
+    {"P", unity::KeyCode::P},
+    {"Q", unity::KeyCode::Q},
+    {"R", unity::KeyCode::R},
+    {"S", unity::KeyCode::S},
+    {"T", unity::KeyCode::T},
+    {"U", unity::KeyCode::U},
+    {"V", unity::KeyCode::V},
+    {"W", unity::KeyCode::W},
+    {"X", unity::KeyCode::X},
+    {"Y", unity::KeyCode::Y},
+    {"Z", unity::KeyCode::Z},
+    {"F1", unity::KeyCode::F1},
+    {"F2", unity::KeyCode::F2},
+    {"F3", unity::KeyCode::F3},
+    {"F4", unity::KeyCode::F4},
+    {"F5", unity::KeyCode::F5},
+    {"F6", unity::KeyCode::F6},
+    {"F7", unity::KeyCode::F7},
+    {"F8", unity::KeyCode::F8},
+    {"F9", unity::KeyCode::F9},
+    {"F10", unity::KeyCode::F10},
+    {"F11", unity::KeyCode::F11},
+    {"F12", unity::KeyCode::F12},
+    {"F13", unity::KeyCode::F13},
+    {"F14", unity::KeyCode::F14},
+    {"F15", unity::KeyCode::F15},
+    {"NUMLOCK", unity::KeyCode::Numlock},
+    {"KEY0", unity::KeyCode::Keypad0},
+    {"KEY1", unity::KeyCode::Keypad1},
+    {"KEY2", unity::KeyCode::Keypad2},
+    {"KEY3", unity::KeyCode::Keypad3},
+    {"KEY4", unity::KeyCode::Keypad4},
+    {"KEY5", unity::KeyCode::Keypad5},
+    {"KEY6", unity::KeyCode::Keypad6},
+    {"KEY7", unity::KeyCode::Keypad7},
+    {"KEY8", unity::KeyCode::Keypad8},
+    {"KEY9", unity::KeyCode::Keypad9},
+    {"KEYDIVIDE", unity::KeyCode::KeypadDivide},
+    {"KEYENTER", unity::KeyCode::KeypadEnter},
+    {"KEYEQUAL", unity::KeyCode::KeypadEquals},
+    {"KEYMINUS", unity::KeyCode::KeypadMinus},
+    {"KEYMULTI", unity::KeyCode::KeypadMultiply},
+    {"KEYPERIOD", unity::KeyCode::KeypadPeriod},
+    {"KEYPLUS", unity::KeyCode::KeypadPlus},
+};
+
+// Modifier names. The unsided ones match either side of the keyboard. Badges use AutoHotkey's ASCII notation.
+struct ModifierName {
+  std::string_view              name;
+  std::array<unity::KeyCode, 2> keys;
+  std::string_view              hint;
+};
+
+constexpr ModifierName kModifiers[] = {
+    {"SHIFT", {unity::KeyCode::LeftShift, unity::KeyCode::RightShift}, "+"},
+    {"CTRL", {unity::KeyCode::LeftControl, unity::KeyCode::RightControl}, "^"},
+    {"ALT", {unity::KeyCode::LeftAlt, unity::KeyCode::RightAlt}, "!"},
+    {"APPLE", {unity::KeyCode::LeftApple, unity::KeyCode::RightApple}, "#"},
+    {"CMD", {unity::KeyCode::LeftCommand, unity::KeyCode::RightCommand}, "#"},
+    {"WIN", {unity::KeyCode::LeftWindows, unity::KeyCode::RightWindows}, "#"},
+    {"LSHIFT", {unity::KeyCode::LeftShift, unity::KeyCode::LeftShift}, "<+"},
+    {"RSHIFT", {unity::KeyCode::RightShift, unity::KeyCode::RightShift}, ">+"},
+    {"LCTRL", {unity::KeyCode::LeftControl, unity::KeyCode::LeftControl}, "<^"},
+    {"RCTRL", {unity::KeyCode::RightControl, unity::KeyCode::RightControl}, ">^"},
+    {"LALT", {unity::KeyCode::LeftAlt, unity::KeyCode::LeftAlt}, "<!"},
+    {"RALT", {unity::KeyCode::RightAlt, unity::KeyCode::RightAlt}, ">!"},
+    {"ALTGR", {unity::KeyCode::AltGr, unity::KeyCode::AltGr}, "!"},
+    {"LAPPLE", {unity::KeyCode::LeftApple, unity::KeyCode::LeftApple}, "<#"},
+    {"LCOM", {unity::KeyCode::LeftCommand, unity::KeyCode::LeftCommand}, "<#"},
+    {"LWIN", {unity::KeyCode::LeftWindows, unity::KeyCode::LeftWindows}, "<#"},
+    {"RAPPLE", {unity::KeyCode::RightApple, unity::KeyCode::RightApple}, ">#"},
+    {"RCOM", {unity::KeyCode::RightCommand, unity::KeyCode::RightCommand}, ">#"},
+    {"RWIN", {unity::KeyCode::RightWindows, unity::KeyCode::RightWindows}, ">#"},
+};
+
+// Settings are only parsed at load, so the tables are searched in order.
+const KeyName* FindKey(std::string_view name)
+{
+  const auto it = std::ranges::find(kKeys, name, &KeyName::name);
+  return it == std::end(kKeys) ? nullptr : it;
+}
+
+const ModifierName* FindModifier(std::string_view name)
+{
+  const auto it = std::ranges::find(kModifiers, name, &ModifierName::name);
+  return it == std::end(kModifiers) ? nullptr : it;
+}
+
+std::array<std::vector<KeyChord>, static_cast<size_t>(Action::kCount)> bindings;
+
+std::vector<KeyChord>& BindingsOf(Action action)
+{ return bindings[static_cast<size_t>(action)]; }
+
+// Keys that completed a binding with modifiers, until released. A plain binding on the same key waits for the
+// release, so letting go of CTRL before PGUP does not turn a held CTRL-PGUP into PGUP.
+std::vector<unity::KeyCode> used_keys;
+
+bool IsUsed(unity::KeyCode key)
+{
+  std::erase_if(used_keys, [](unity::KeyCode used) { return !unity::Key::Pressed(used); });
+  return std::ranges::find(used_keys, key) != used_keys.end();
+}
+
+bool ModifiersHeld(const KeyChord& chord)
+{
+  return std::ranges::all_of(chord.modifiers,
+                             [](const auto& group) { return std::ranges::any_of(group, unity::Key::Pressed); });
+}
+
+template <bool (*KeyState)(unity::KeyCode)> bool Matches(Action action)
+{
+  for (const auto& chord : BindingsOf(action)) {
+    if (chord.key == unity::KeyCode::None || !KeyState(chord.key))
+      continue;
+    if (chord.modifiers.empty() ? unity::Key::IsModified() || IsUsed(chord.key) : !ModifiersHeld(chord))
+      continue;
+    if (!chord.modifiers.empty() && std::ranges::find(used_keys, chord.key) == used_keys.end())
+      used_keys.push_back(chord.key);
+    return true;
+  }
+  return false;
+}
+
+enum class Tier { kAlways, kExtended, kExperimental };
+
+struct Setting {
+  std::string_view                key;
+  Action                          action;
+  std::string_view                fallback;
+  Tier                            tier    = Tier::kAlways;
+  std::array<std::string_view, 2> aliases = {};
+};
+
+// Order is the order of the debug log; the TOML output is sorted by key anyway.
+constexpr Setting kSettings[] = {
+    {"move_up", Action::kMoveUp, "W|UP"},
+    {"move_down", Action::kMoveDown, "S|DOWN"},
+    {"move_left", Action::kMoveLeft, "A|LEFT"},
+    {"move_right", Action::kMoveRight, "D|RIGHT"},
+    {"set_hotkeys_disabled",
+     Action::kDisableHotKeys,
+     "CTRL-ALT-MINUS",
+     Tier::kAlways,
+     {"set_hotkeys_disble", "set_hotkeys_disable"}},
+    {"set_hotkeys_enabled", Action::kEnableHotKeys, "CTRL-ALT-=", Tier::kAlways, {"set_hotkeys_enable"}},
+    {"select_chatalliance", Action::kSelectChatAlliance, "CTRL-2"},
+    {"select_chatglobal", Action::kSelectChatGlobal, "CTRL-1"},
+    {"select_chatprivate", Action::kSelectChatPrivate, "CTRL-3"},
+    {"quit", Action::kQuit, "F10"},
+    {"select_ship1", Action::kSelectShip1, "1"},
+    {"select_ship2", Action::kSelectShip2, "2"},
+    {"select_ship3", Action::kSelectShip3, "3"},
+    {"select_ship4", Action::kSelectShip4, "4"},
+    {"select_ship5", Action::kSelectShip5, "5"},
+    {"select_ship6", Action::kSelectShip6, "6"},
+    {"select_ship7", Action::kSelectShip7, "7"},
+    {"select_ship8", Action::kSelectShip8, "8"},
+    {"select_current", Action::kSelectCurrent, "CTRL-SPACE"},
+    {"focus_search", Action::kFocusSearch, "CTRL-F"},
+    {"action_primary", Action::kActionPrimary, "SPACE|MOUSE1"},
+    {"action_secondary", Action::kActionSecondary, "TAB|MOUSE4"},
+    {"action_queue", Action::kActionQueue, "SPACE|MOUSE1"},
+    {"action_queue_clear", Action::kActionQueueClear, "CTRL-C"},
+    {"action_view", Action::kActionView, "V|MOUSE2"},
+    {"action_recall", Action::kActionRecall, "R|MOUSE3"},
+    {"action_recall_cancel", Action::kActionRecallCancel, "SPACE|MOUSE1"},
+    {"action_repair", Action::kActionRepair, "R|MOUSE3"},
+    {"show_chat", Action::kShowChat, "C"},
+    {"show_chatside1", Action::kShowChatSide1, "ALT-C"},
+    {"show_chatside2", Action::kShowChatSide2, "`"},
+    {"show_galaxy", Action::kShowGalaxy, "G"},
+    {"show_galaxy_native", Action::kNativeShortcutGalaxy, "CTRL-G", Tier::kAlways, {"native_shortcut_galaxy"}},
+    {"show_system", Action::kShowSystem, "H"},
+    {"zoom_preset1", Action::kZoomPreset1, "F1"},
+    {"zoom_preset2", Action::kZoomPreset2, "F2"},
+    {"zoom_preset3", Action::kZoomPreset3, "F3"},
+    {"zoom_preset4", Action::kZoomPreset4, "F4"},
+    {"zoom_preset5", Action::kZoomPreset5, "F5"},
+    {"zoom_in", Action::kZoomIn, "Q"},
+    {"zoom_out", Action::kZoomOut, "E"},
+    {"zoom_max", Action::kZoomMax, "MINUS"},
+    {"zoom_min", Action::kZoomMin, "BACKSPACE"},
+    {"zoom_reset", Action::kZoomReset, "="},
+    {"ui_scaleup", Action::kUiScaleUp, "PGUP"},
+    {"ui_scaledown", Action::kUiScaleDown, "PGDOWN"},
+    {"ui_scaleshipup", Action::kUiShipScaleUp, "CTRL-PGUP"},
+    {"ui_scaleshipdown", Action::kUiShipScaleDown, "CTRL-PGDOWN"},
+    {"ui_scaleviewerup", Action::kUiViewerScaleUp, "SHIFT-PGUP"},
+    {"ui_scaleviewerdown", Action::kUiViewerScaleDown, "SHIFT-PGDOWN"},
+    {"log_debug", Action::kLogLevelDebug, "CTRL-SHIFT-F9"},
+    {"log_trace", Action::kLogLevelTrace, "CTRL-SHIFT-F7"},
+    {"log_info", Action::kLogLevelInfo, "CTRL-SHIFT-F8"},
+    {"log_warn", Action::kLogLevelWarn, "CTRL-SHIFT-F10"},
+    {"log_error", Action::kLogLevelError, "CTRL-SHIFT-F11"},
+    {"log_off", Action::kLogLevelOff, "CTRL-SHIFT-F12"},
+    {"restart", Action::kRestart, "F9"},
+    {"reload_settings", Action::kReloadSettings, "CTRL-SHIFT-F6"},
+    {"show_awayteam", Action::kShowAwayTeam, "T"},
+    {"show_gifts", Action::kShowGifts, "/"},
+    {"show_artifacts", Action::kShowArtifacts, "SHIFT-I"},
+    {"show_commander", Action::kShowCommander, "O"},
+    {"show_daily", Action::kShowDaily, "Z"},
+    {"show_events", Action::kShowEvents, "SHIFT-E"},
+    {"show_events_native", Action::kNativeShortcutEvents, "CTRL-E", Tier::kAlways, {"native_shortcut_events"}},
+    {"show_exocomp", Action::kShowExoComp, "X"},
+    {"show_factions", Action::kShowFactions, "F"},
+    {"show_inventory", Action::kShowInventory, "I"},
+    {"show_missions", Action::kShowMissions, "M"},
+    {"show_research", Action::kShowResearch, "U"},
+    {"show_scrapyard", Action::kShowScrapYard, "Y"},
+    {"show_settings", Action::kShowSettings, "SHIFT-S"},
+    {"toggle_shortcut_hints", Action::kToggleShortcutHints, "HOME"},
+    {"show_officers", Action::kShowOfficers, "SHIFT-O"},
+    {"show_officerpresets", Action::kShowOfficerPresets, "CTRL-O"},
+    {"show_officerswap", Action::kShowOfficerSwap, "ALT-O"},
+    {"show_qtrials", Action::kShowQTrials, "SHIFT-Q"},
+    {"show_refinery", Action::kShowRefinery, "SHIFT-F"},
+    {"show_ships", Action::kShowShips, "N"},
+    {"show_shipconstruction", Action::kShowShipConstruction, "SHIFT-N"},
+    {"show_shipswap", Action::kShowShipSwap, "ALT-N"},
+    {"show_shields", Action::kShowShields, "CTRL-S"},
+    {"show_battlelogs", Action::kShowBattlelogs, "SHIFT-B"},
+    {"show_stationexterior", Action::kShowStationExterior, "SHIFT-G"},
+    {"show_stationinterior", Action::kShowStationInterior, "SHIFT-H"},
+    {"show_haven", Action::kShowHaven, "ALT-H"},
+    {"toggle_queue", Action::kToggleQueue, "CTRL-Q"},
+    {"toggle_instant_warp", Action::kToggleAutoConfirmInstantWarp, "ALT-I"},
+    {"show_alliance", Action::kShowAlliance, "ALT-'", Tier::kExtended},
+    {"show_alliance_help", Action::kShowAllianceHelp, "SHIFT-'", Tier::kExperimental},
+    {"show_alliance_armada", Action::kShowAllianceArmada, "CTRL-'", Tier::kExperimental},
+    {"show_bookmarks", Action::kShowBookmarks, "B", Tier::kExtended},
+    {"show_lookup", Action::kShowLookup, "L", Tier::kExperimental},
+    {"set_zoom_preset1", Action::kSetZoomPreset1, "SHIFT-F1", Tier::kExtended},
+    {"set_zoom_preset2", Action::kSetZoomPreset2, "SHIFT-F2", Tier::kExtended},
+    {"set_zoom_preset3", Action::kSetZoomPreset3, "SHIFT-F3", Tier::kExtended},
+    {"set_zoom_preset4", Action::kSetZoomPreset4, "SHIFT-F4", Tier::kExtended},
+    {"set_zoom_preset5", Action::kSetZoomPreset5, "SHIFT-F5", Tier::kExtended},
+    {"set_zoom_default", Action::kSetZoomDefault, "CTRL-=", Tier::kExtended},
+    {"toggle_preview_locate", Action::kTogglePreviewLocate, "CTRL-R", Tier::kExtended},
+    {"toggle_preview_recall", Action::kTogglePreviewRecall, "CTRL-T", Tier::kExtended},
+    {"toggle_cargo_default", Action::kToggleCargoDefault, "ALT-1", Tier::kExtended},
+    {"toggle_cargo_player", Action::kToggleCargoPlayer, "ALT-2", Tier::kExtended},
+    {"toggle_cargo_station", Action::kToggleCargoStation, "ALT-3", Tier::kExtended},
+    {"toggle_cargo_hostile", Action::kToggleCargoHostile, "ALT-4", Tier::kExtended},
+    {"toggle_cargo_armada", Action::kToggleCargoArmada, "ALT-5", Tier::kExtended},
+};
+
+// Binds every chord in `value` ("CTRL-G|F8"). Reports whether any was valid.
+bool BindChords(const Setting& setting, std::string_view key, std::string_view value)
+{
+  bool bound = false;
+  for (const auto& text : StrSplit(value, '|')) {
+    if (auto chord = KeyChord::Parse(text); chord.key != unity::KeyCode::None) {
+      Shortcut::Bind(setting.action, std::move(chord));
+      bound = true;
+    } else {
+      spdlog::warn("Invalid shortcut token [shortcuts].{} token='{}' value='{}'; ignoring token.", key, text, value);
+    }
+  }
+  return bound;
+}
+
+// Binds one [shortcuts] setting and records the effective binding, and where it came from, in `out`.
+void LoadSetting(const toml::table* shortcuts, toml::table& out, toml::table& out_source, const Setting& setting)
+{
+  // The setting itself, else the first deprecated alias present, else the default.
+  std::string_view  key  = setting.key;
+  const toml::node* node = shortcuts ? shortcuts->get(key) : nullptr;
+  for (const auto alias : setting.aliases) {
+    if (alias.empty() || !shortcuts || !shortcuts->contains(alias))
+      continue;
+    if (node) {
+      spdlog::warn("Ignoring deprecated shortcut alias [shortcuts].{} because [shortcuts].{} is set.", alias,
+                   setting.key);
+      continue;
+    }
+    spdlog::warn("Deprecated shortcut alias [shortcuts].{} is supported for compatibility; use [shortcuts].{}.", alias,
+                 setting.key);
+    key  = alias;
+    node = shortcuts->get(alias);
+    break;
+  }
+  std::optional<std::string> configured = node ? node->value<std::string>() : std::nullopt;
+  if (node && !configured)
+    spdlog::error("Invalid shortcut value [shortcuts].{} must be a string; using default for [shortcuts].{}.", key,
+                  setting.key);
+  std::string label = !configured ? "default" : key == setting.key ? "config" : "alias:" + std::string(key);
+
+  const auto record = [&](std::string value, std::string source) {
+    spdlog::debug("shortcut value shortcuts.{} value: {}", setting.key, value);
+    out.insert_or_assign(setting.key, std::move(value));
+    out_source.insert_or_assign(setting.key, std::move(source));
+  };
+
+  // An explicit empty string disables the binding, just like NONE.
+  const auto value = AsciiStrToUpper(StripAsciiWhitespace(configured.value_or(std::string(setting.fallback))));
+  if (value.empty() || value == "NONE")
+    return record("NONE", label);
+
+  if (!BindChords(setting, key, value)) {
+    if (configured)
+      spdlog::error("No valid shortcut tokens for [shortcuts].{} value='{}'; using default for [shortcuts].{}.", key,
+                    *configured, setting.key);
+    if (!configured || !BindChords(setting, setting.key, setting.fallback)) {
+      spdlog::error("Default shortcut [shortcuts].{} value='{}' has no valid tokens; action disabled.", setting.key,
+                    setting.fallback);
+      return record("NONE", "invalid");
+    }
+    label = "default";
+  }
+  record(Shortcut::Describe(setting.action), label);
+}
+} // namespace
+
+KeyChord KeyChord::Parse(std::string_view text)
+{
+  KeyChord    chord;
+  std::string key_token;
+  for (auto& token : StrSplit(AsciiStrToUpper(text), '-')) {
+    if (const auto* modifier = FindModifier(token)) {
+      chord.modifiers.push_back(modifier->keys);
+      chord.tokens.push_back(std::move(token));
+    } else if (const auto* key = FindKey(token)) {
+      // A chord has one key; a later one replaces an earlier one, so the text shows what is bound.
+      chord.key = key->key;
+      key_token = std::move(token);
+    }
+  }
+  if (chord.key != unity::KeyCode::None)
+    chord.tokens.push_back(std::move(key_token));
+  return chord;
+}
+
+std::string KeyChord::Text() const
+{
+  std::string text;
+  for (const auto& token : tokens) {
+    if (!text.empty())
+      text += '-';
+    text += token;
+  }
+  return text;
+}
+
+std::string KeyChord::Hint() const
+{
+  std::string hint;
+  for (size_t i = 0; i < tokens.size(); ++i) {
+    // The key is always last; everything before it is a modifier.
+    const auto* key      = i + 1 == tokens.size() && this->key != unity::KeyCode::None ? FindKey(tokens[i]) : nullptr;
+    const auto* modifier = key ? nullptr : FindModifier(tokens[i]);
+    hint += key && !key->hint.empty() ? key->hint : modifier ? modifier->hint : std::string_view(tokens[i]);
+  }
+  return hint;
+}
+
+namespace Shortcut
+{
+void Load(const toml::table& config, toml::table& parsed, bool extended, bool experimental)
+{
+  // A reload replaces every binding.
+  Clear();
+  const auto* shortcuts = config["shortcuts"].as_table();
+  auto&       out       = *parsed.emplace<toml::table>("shortcuts").first->second.as_table();
+  auto&       source    = *parsed.emplace<toml::table>("shortcuts_source").first->second.as_table();
+
+  for (const auto& setting : kSettings) {
+    if ((setting.tier == Tier::kExtended && !extended)
+        || (setting.tier == Tier::kExperimental && !(extended && experimental)))
+      continue;
+    LoadSetting(shortcuts, out, source, setting);
+  }
+}
+
+void Bind(Action action, KeyChord chord)
+{ BindingsOf(action).push_back(std::move(chord)); }
+
+void Clear()
+{
+  for (auto& chords : bindings)
+    chords.clear();
+  used_keys.clear();
+}
+
+bool Owns(unity::KeyCode key)
+{ return IsUsed(key); }
+
+bool HasBinding(Action action)
+{
+  return std::ranges::any_of(BindingsOf(action), [](const auto& chord) { return chord.key != unity::KeyCode::None; });
+}
+
+bool IsPressed(Action action)
+{ return Matches<unity::Key::Pressed>(action); }
+
+bool IsDown(Action action)
+{ return Matches<unity::Key::Down>(action); }
+
+std::string Describe(Action action)
+{
+  std::string text;
+  for (const auto& chord : BindingsOf(action)) {
+    if (!text.empty())
+      text += " | ";
+    text += chord.Text();
+  }
+  return text;
+}
+
+std::string Hint(Action action)
+{
+  // The game's badges have room for one binding.
+  return BindingsOf(action).empty() ? std::string{} : BindingsOf(action).front().Hint();
+}
+} // namespace Shortcut
diff --git a/mods/src/patches/shortcuts.h b/mods/src/patches/shortcuts.h
new file mode 100644
index 000000000..caff7c81b
--- /dev/null
+++ b/mods/src/patches/shortcuts.h
@@ -0,0 +1,169 @@
+#pragma once
+
+// Configurable shortcuts: the actions they trigger, parsing [shortcuts] from the settings file, and
+// matching the parsed key chords against this frame's input.
+
+#include <toml++/toml.h>
+#include <unity/input.h>
+
+#include <array>
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <vector>
+
+// What a shortcut does. Each [shortcuts] setting binds key chords to one action.
+enum class Action : uint8_t {
+  kMoveLeft,
+  kMoveRight,
+  kMoveUp,
+  kMoveDown,
+  kSelectChatAlliance,
+  kSelectChatGlobal,
+  kSelectChatPrivate,
+  kSelectShip1,
+  kSelectShip2,
+  kSelectShip3,
+  kSelectShip4,
+  kSelectShip5,
+  kSelectShip6,
+  kSelectShip7,
+  kSelectShip8,
+  kSelectCurrent,
+  kShowAlliance,
+  kShowAllianceArmada,
+  kShowAllianceHelp,
+  kShowArtifacts,
+  kShowOfficers,
+  kShowOfficerPresets,
+  kShowCommander,
+  kShowRefinery,
+  kShowQTrials,
+  kShowBookmarks,
+  kShowLookup,
+  kShowExoComp,
+  kShowFactions,
+  kShowGifts,
+  kShowDaily,
+  kShowAwayTeam,
+  kShowMissions,
+  kShowResearch,
+  kShowScrapYard,
+  kShowShips,
+  kShowInventory,
+  kShowStationInterior,
+  kShowHaven,
+  kShowStationExterior,
+  kShowGalaxy,
+  kNativeShortcutGalaxy,
+  kShowSystem,
+  kShowChat,
+  kShowChatSide1,
+  kShowChatSide2,
+  kShowEvents,
+  kNativeShortcutEvents,
+  kShowSettings,
+  kToggleShortcutHints,
+  kZoomPreset1,
+  kZoomPreset2,
+  kZoomPreset3,
+  kZoomPreset4,
+  kZoomPreset5,
+  kZoomIn,
+  kZoomOut,
+  kZoomMin,
+  kZoomMax,
+  kZoomReset,
+  kUiScaleUp,
+  kUiScaleDown,
+  kUiShipScaleUp,
+  kUiShipScaleDown,
+  kUiViewerScaleUp,
+  kUiViewerScaleDown,
+  kActionPrimary,
+  kActionSecondary,
+  kActionQueue,
+  kActionQueueClear,
+  kActionView,
+  kActionRecall,
+  kActionRecallCancel,
+  kActionRepair,
+  kSetZoomPreset1,
+  kSetZoomPreset2,
+  kSetZoomPreset3,
+  kSetZoomPreset4,
+  kSetZoomPreset5,
+  kSetZoomDefault,
+  kDisableHotKeys,
+  kEnableHotKeys,
+  kToggleQueue,
+  kToggleAutoConfirmInstantWarp,
+  kTogglePreviewLocate,
+  kTogglePreviewRecall,
+  kToggleCargoDefault,
+  kToggleCargoPlayer,
+  kToggleCargoStation,
+  kToggleCargoHostile,
+  kToggleCargoArmada,
+  kLogLevelDebug,
+  kLogLevelInfo,
+  kLogLevelTrace,
+  kLogLevelError,
+  kLogLevelWarn,
+  kLogLevelOff,
+  kRestart,
+  kReloadSettings,
+  kQuit,
+  kFocusSearch,
+  kShowShipConstruction,
+  kShowOfficerSwap,
+  kShowShipSwap,
+  kShowShields,
+  kShowBattlelogs,
+
+  kCount
+};
+
+// One key with its required modifiers, such as CTRL-SHIFT-F1.
+struct KeyChord {
+  unity::KeyCode key = unity::KeyCode::None;
+  // Each group is satisfied by either of its keys: SHIFT is {LeftShift, RightShift}, LSHIFT is LeftShift twice.
+  std::vector<std::array<unity::KeyCode, 2>> modifiers;
+  // The upper-cased tokens for display, modifiers first and the key last: {"CTRL", "SHIFT", "F1"}.
+  std::vector<std::string> tokens;
+
+  // Parses one chord. Unknown tokens are ignored; a chord without a non-modifier key has key == None. With two
+  // keys, the last one counts.
+  static KeyChord Parse(std::string_view text);
+
+  // "CTRL-SHIFT-F1"
+  std::string Text() const;
+  // Compact form for the game's keybind badges: "^+F1".
+  std::string Hint() const;
+};
+
+namespace Shortcut
+{
+// Replaces every binding with the [shortcuts] entries from `config`, and records the effective bindings and where
+// each came from in `parsed` ([shortcuts] and [shortcuts_source]). `extended` and `experimental` gate the optional
+// actions.
+void Load(const toml::table& config, toml::table& parsed, bool extended, bool experimental);
+
+// Adds a binding directly. Load uses this; tests use it to set up bindings.
+void Bind(Action action, KeyChord chord);
+void Clear();
+
+bool HasBinding(Action action);
+// Any binding of `action` is held with its modifiers. A binding without modifiers needs none held; one with
+// modifiers still fires when extra modifiers are held (CTRL-F1 fires under CTRL+SHIFT).
+bool IsPressed(Action action);
+// Any binding of `action` went down this frame with its modifiers held.
+bool IsDown(Action action);
+// A binding with modifiers matched on `key`, which is still held. Plain bindings on it wait for the release.
+bool Owns(unity::KeyCode key);
+
+// "CTRL-G | F8"
+std::string Describe(Action action);
+// The badge text of the first binding, or empty when unbound.
+std::string Hint(Action action);
+} // namespace Shortcut
diff --git a/mods/src/prime/ActionData.h b/mods/src/prime/ActionData.h
deleted file mode 100644
index e7f7505a9..000000000
--- a/mods/src/prime/ActionData.h
+++ /dev/null
@@ -1,69 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-using IActionData = void*;
-
-// Digit.PrimeServer.Models.ActionType is a struct around a flag value, not an enum, so it crosses the
-// managed boundary as a 4-byte struct.
-struct ActionType {
-  int32_t flagValue;
-
-  friend bool operator==(ActionType, ActionType) = default;
-
-  static const ActionType Invalid;
-  static const ActionType Upgrade;
-  static const ActionType Purchase;
-  static const ActionType Manage;
-  static const ActionType Harvest;
-  static const ActionType Repair;
-  static const ActionType View;
-  static const ActionType Recall;
-  static const ActionType Promote;
-  static const ActionType Demote;
-  static const ActionType Move;
-  static const ActionType Attack;
-  static const ActionType Assign;
-  static const ActionType Add;
-  static const ActionType Remove;
-  static const ActionType Claim;
-  static const ActionType Chat;
-  static const ActionType Help;
-  static const ActionType Invite;
-  static const ActionType Report;
-  static const ActionType Copy;
-  static const ActionType Share;
-};
-
-inline constexpr ActionType ActionType::Invalid {-1};
-inline constexpr ActionType ActionType::Upgrade {1433481724};
-inline constexpr ActionType ActionType::Purchase{1807968545};
-inline constexpr ActionType ActionType::Manage  {-1997567611};
-inline constexpr ActionType ActionType::Harvest {-1933286583};
-inline constexpr ActionType ActionType::Repair  {-1850668115};
-inline constexpr ActionType ActionType::View    {2666181};
-inline constexpr ActionType ActionType::Recall  {-1851055311};
-inline constexpr ActionType ActionType::Promote {1355442080};
-inline constexpr ActionType ActionType::Demote  {2043415476};
-inline constexpr ActionType ActionType::Move    {2404337};
-inline constexpr ActionType ActionType::Attack  {1971575400};
-inline constexpr ActionType ActionType::Assign  {1970629903};
-inline constexpr ActionType ActionType::Add     {65665};
-inline constexpr ActionType ActionType::Remove  {-1850743644};
-inline constexpr ActionType ActionType::Claim   {65189916};
-inline constexpr ActionType ActionType::Chat    {2099064};
-inline constexpr ActionType ActionType::Help    {2245473};
-inline constexpr ActionType ActionType::Invite  {-2099832023};
-inline constexpr ActionType ActionType::Report  {-1850654380};
-inline constexpr ActionType ActionType::Copy    {2106261};
-inline constexpr ActionType ActionType::Share   {79847359};
-
-
-enum ActionBehaviour {
-  Default             = 1,
-  Instant             = 2,
-  Speedup             = 4,
-  Collect             = 8,
-  AskHelp             = 16,
-  RequestConfirmation = 32,
-};
\ No newline at end of file
diff --git a/mods/src/prime/ActionQueueManager.h b/mods/src/prime/ActionQueueManager.h
deleted file mode 100644
index 1e9dae326..000000000
--- a/mods/src/prime/ActionQueueManager.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "FleetPlayerData.h"
-#include "MonoSingleton.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct ActionQueueManager : MonoSingleton<ActionQueueManager> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Prime.ActionQueue", "ActionQueueManager">;
-
-  void ClearQueue(FleetPlayerData* playerData)
-  { Call<"ClearQueue">(playerData); }
-  bool IsQueueFull(FleetPlayerData* playerData)
-  { return Call<"IsQueueFull", bool>(playerData); }
-  bool IsFleetInQueue(FleetPlayerData* playerData)
-  { return Call<"IsFleetInQueue", bool>(playerData); }
-  bool IsQueueUnlocked()
-  { return Call<"IsQueueUnlocked", bool>(); }
-
-  bool CanAddToQueue(FleetPlayerData* playerData)
-  { return IsQueueUnlocked() && !IsQueueFull(playerData); }
-
-  void AddToQueue(int64_t targetId)
-  { Call<"AddActionToQueue">(targetId); }
-};
diff --git a/mods/src/prime/ActionRequirement.h b/mods/src/prime/ActionRequirement.h
deleted file mode 100644
index 7f6aa85af..000000000
--- a/mods/src/prime/ActionRequirement.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct ActionRequirement : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "ActionRequirement">;
-
-  bool IsMet()
-  { return Get<"IsMet", bool>(); }
-  bool CheckIsMet()
-  { return Call<"CheckIsMet", bool>(); }
-};
diff --git a/mods/src/prime/ActivatedAbilityManager.h b/mods/src/prime/ActivatedAbilityManager.h
deleted file mode 100644
index 630755604..000000000
--- a/mods/src/prime/ActivatedAbilityManager.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-#include "MonoSingleton.h"
-#include "FleetPlayerData.h"
-
-struct ActivatedAbilityManager : MonoSingleton<ActivatedAbilityManager> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ActivatedAbilities", "ActivatedAbilityManager">;
-  static constexpr int32_t RevealHostileVgerAbilityType = 86002;
-  int32_t GetActivatedAbilityType(int64_t abilityId)
-  { return Call<"GetActivatedAbilityType", int32_t>(abilityId); }
-  bool CanUseAbility(FleetPlayerData* fleet, int64_t abilityId)
-  { return Call<"CanUseAbility", bool>(fleet, abilityId); }
-};
diff --git a/mods/src/prime/AllianceStarbaseObjectViewerWidget.h b/mods/src/prime/AllianceStarbaseObjectViewerWidget.h
deleted file mode 100644
index fa6504a64..000000000
--- a/mods/src/prime/AllianceStarbaseObjectViewerWidget.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include "ObjectViewerBaseWidget.h"
-
-struct AllianceStarbaseObjectViewerWidget : ObjectViewerBaseWidget {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "AllianceStarbaseObjectViewerWidget">;
-};
diff --git a/mods/src/prime/AnimatedRewardsScreenViewController.h b/mods/src/prime/AnimatedRewardsScreenViewController.h
deleted file mode 100644
index 156f3155d..000000000
--- a/mods/src/prime/AnimatedRewardsScreenViewController.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct AnimatedRewardsScreenViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Missions.UI", "AnimatedRewardsScreenViewController">;
-
-  void GoBackToLastSection()
-  { Call<"GoBackToLastSection">(); }
-  void OnCollectClicked()
-  { Call<"OnCollectClicked">(); }
-  bool IsActive()
-  { return Call<"IsActive", bool>(); }
-};
diff --git a/mods/src/prime/ArmadaObjectViewerWidget.h b/mods/src/prime/ArmadaObjectViewerWidget.h
deleted file mode 100644
index b86ff3a2f..000000000
--- a/mods/src/prime/ArmadaObjectViewerWidget.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include "FleetPlayerData.h"
-#include "GenericButtonContext.h"
-#include "ObjectViewerBaseWidget.h"
-
-struct ArmadaObjectViewerWidget : ObjectViewerBaseWidget {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "ArmadaObjectViewerWidget">;
-
-  void SetCourseToArmada()
-  { Call<"SetCourseToArmada">(); }
-  void ValidateThenJoinArmada()
-  { Call<"ValidateThenJoinArmada">(); }
-  void JoinArmada()
-  { Call<"JoinArmada">(); }
-  bool IsAllowedToJoinArmada(FleetPlayerData* fleet)
-  { return Call<"IsAllowedToJoinArmada", bool>(fleet); }
-
-  GenericButtonContext* joinContext()
-  { return Field<"_joinContext", GenericButtonContext*>(); }
-};
diff --git a/mods/src/prime/ArtifactHallDetailsViewController.h b/mods/src/prime/ArtifactHallDetailsViewController.h
deleted file mode 100644
index 0d676c219..000000000
--- a/mods/src/prime/ArtifactHallDetailsViewController.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#pragma once
-
-#include "SemaphoreButtonListener.h"
-
-#include <il2cpp/il2cpp.h>
-#include <spdlog/spdlog.h>
-
-struct ArtifactHallDetailsViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ArtifactHall", "ArtifactHallDetailsViewController">;
-
-  // Treat the controller as active if the icall is unavailable, so the arrow hotkeys still try.
-  bool isActiveAndEnabled()
-  {
-    static auto get_isActiveAndEnabled = il2cpp::ResolveICall<bool(ArtifactHallDetailsViewController*)>(
-        "UnityEngine.Behaviour::get_isActiveAndEnabled()");
-    return get_isActiveAndEnabled ? get_isActiveAndEnabled(this) : true;
-  }
-
-  void PressLeftArrow()
-  {
-    auto* listener = leftArrowButton();
-    if (!listener) {
-      spdlog::trace("No left button listener");
-      return;
-    }
-    auto* button = listener->TheButton();
-    if (!button) {
-      spdlog::trace("No left button");
-      return;
-    }
-    button->Press();
-  }
-
-  void PressRightArrow()
-  {
-    auto* listener = rightArrowButton();
-    if (!listener) {
-      spdlog::info("No right button listener");
-      return;
-    }
-    auto* button = listener->TheButton();
-    if (!button) {
-      spdlog::info("No right button");
-      return;
-    }
-    button->Press();
-  }
-
-  SemaphoreButtonListener* leftArrowButton()
-  { return Field<"_leftArrowButton", SemaphoreButtonListener*>(); }
-  SemaphoreButtonListener* rightArrowButton()
-  { return Field<"_rightArrowButton", SemaphoreButtonListener*>(); }
-};
diff --git a/mods/src/prime/AspectRatioConstraintHandler.h b/mods/src/prime/AspectRatioConstraintHandler.h
deleted file mode 100644
index d66498f66..000000000
--- a/mods/src/prime/AspectRatioConstraintHandler.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#if _WIN32
-
-#include <il2cpp/il2cpp.h>
-
-struct AspectRatioConstraintHandler {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Utils", "AspectRatioConstraintHandler">;
-
-  static WNDPROC _unityWndProc()
-  { return reinterpret_cast<WNDPROC>(Class::Field<"_unityWndProc", intptr_t>()); }
-};
-
-#endif
diff --git a/mods/src/prime/AssignShipsWidget.h b/mods/src/prime/AssignShipsWidget.h
deleted file mode 100644
index e72e35d1c..000000000
--- a/mods/src/prime/AssignShipsWidget.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "ButtonAndContextWrapper.h"
-#include "InputFieldWidget.h"
-#include "SelectableList.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct AssignShipsWidget : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "AssignShipsWidget">;
-
-  InputFieldWidget* inputField()
-  { return Field<"_inputField", InputFieldWidget*>(); }
-  bool isActiveAndEnabled()
-  { return Get<"isActiveAndEnabled", bool>(); }
-  ButtonAndContextWrapper* assignButton()
-  { return Field<"_assignButton", ButtonAndContextWrapper*>(); }
-  SelectableList* selectableList()
-  { return Field<"_selectableList", SelectableList*>(); }
-};
diff --git a/mods/src/prime/BattleResultHeader.h b/mods/src/prime/BattleResultHeader.h
deleted file mode 100644
index 40f5ec1e5..000000000
--- a/mods/src/prime/BattleResultHeader.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-enum class BattleType : int32_t {
-  Fleet                       = 0,
-  Base                        = 1,
-  PassiveMarauder             = 2,
-  NpcInstantiated             = 3,
-  DockingPoint                = 4,
-  ActiveMarauder_MarauderInit = 5,
-  ActiveMarauder_PlayerInit   = 6,
-  ArmadaBase                  = 7,
-  ArmadaMarauder              = 8,
-  PveDockingPoint             = 9,
-  ArmadaAsb                   = 10,
-  ArmadaMta                   = 11,
-  Hazard                      = 12,
-  PveCuttingBeam              = 13,
-  PvpCuttingBeam              = 14,
-  PveChainShot                = 15,
-  PvpChainShot                = 16
-};
-
-enum class BattleResultType : int32_t {
-  Defeat         = 0,
-  Victory        = 1,
-  PartialVictory = 2
-};
-
-enum class FleetDataType : int32_t {
-  DeployedFleet = 0,
-  Starbase      = 1,
-  Armada        = 2
-};
-
-struct BattleResultHeader : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "BattleResultHeader">;
-
-  Il2CppObject* get_PlayerUserProfile()
-  { return Get<"PlayerUserProfile", Il2CppObject*>(); }
-  Il2CppObject* get_EnemyUserProfile()
-  { return Get<"EnemyUserProfile", Il2CppObject*>(); }
-  Il2CppObject* get_SpecService()
-  { return Field<"_specService", Il2CppObject*>(); }
-  int32_t get_BattleType()
-  { return Get<"BattleType", int32_t>(); }
-
-  int64_t PlayerShipHullId()
-  { return Get<"PlayerShipHullId", int64_t>(); }
-  int64_t EnemyShipHullId()
-  { return Get<"EnemyShipHullId", int64_t>(); }
-};
diff --git a/mods/src/prime/BattleTargetData.h b/mods/src/prime/BattleTargetData.h
deleted file mode 100644
index 6361b81e7..000000000
--- a/mods/src/prime/BattleTargetData.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include "FleetDeployedData.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct BattleTargetData : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "BattleTargetData">;
-
-  FleetDeployedData* TargetFleetDeployedData()
-  { return Field<"TargetFleetDeployedData", FleetDeployedData*>(); }
-};
diff --git a/mods/src/prime/BlurController.h b/mods/src/prime/BlurController.h
deleted file mode 100644
index 866d65b00..000000000
--- a/mods/src/prime/BlurController.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct BlurController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.LoadingScreen", "BlurController">;
-
-  float blurTime()
-  { return Field<"_blurTime", float>(); }
-  void SetBlurTime(float value)
-  { SetField<"_blurTime">(value); }
-  int32_t waitFrames()
-  { return Field<"_waitFrames", int32_t>(); }
-  void SetWaitFrames(int32_t value)
-  { SetField<"_waitFrames">(value); }
-
-  void ForceCompletion()
-  { Call<"ForceCompletion">(); }
-};
diff --git a/mods/src/prime/BookmarksManager.h b/mods/src/prime/BookmarksManager.h
deleted file mode 100644
index a491a5ba8..000000000
--- a/mods/src/prime/BookmarksManager.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include "Hub.h"
-#include "MonoSingleton.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct CoordinateSearchContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Bookmarks", "CoordinateSearchContext">;
-
-  void SetDefaultXCoordinate(Il2CppString* value)
-  { Set<"DefaultXCoordinate">(value); }
-  void SetDefaultYCoordinate(Il2CppString* value)
-  { Set<"DefaultYCoordinate">(value); }
-  void SetDefaultSystemInput(Il2CppString* value)
-  { Set<"DefaultSystemInput">(value); }
-};
-
-struct BookmarksManager : MonoSingleton<BookmarksManager> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Bookmarks", "BookmarksManager">;
-
-  void ViewBookmarks()
-  { Call<"ViewBookmarks">(); }
-
-  void ViewCoordinateSearch()
-  {
-    auto* context = il2cpp::New<CoordinateSearchContext>();
-    // The binding already reported the missing class or constructor; plain bookmarks are the next best view.
-    if (!context) {
-      ViewBookmarks();
-      return;
-    }
-
-    auto* zero = il2cpp_string_new("0");
-    context->SetDefaultXCoordinate(zero);
-    context->SetDefaultYCoordinate(zero);
-    context->SetDefaultSystemInput(il2cpp_string_new(""));
-    Hub::get_SectionManager()->TriggerSectionChange(SectionID::Bookmarks_Search_Coordinates, context, false, false,
-                                                    true);
-  }
-};
diff --git a/mods/src/prime/Bundle.h b/mods/src/prime/Bundle.h
deleted file mode 100644
index 30fe1e564..000000000
--- a/mods/src/prime/Bundle.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct Bundle : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimePlatform.Content", "Bundle">;
-};
diff --git a/mods/src/prime/BundleDataWidget.h b/mods/src/prime/BundleDataWidget.h
deleted file mode 100644
index 0c34585e8..000000000
--- a/mods/src/prime/BundleDataWidget.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#include "Bundle.h"
-#include "Widget.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct BundleDataWidget : Widget<Bundle> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Shop", "BundleDataWidget">;
-
-  enum ItemState : int32_t {
-    None               = 0,
-    Package            = 1,
-    Highlighted        = 2,
-    LegendOn           = 4,
-    ExpiryTimerOn      = 8,
-    DiscountOn         = 16,     // 0x00000010
-    RemoteImage        = 32,     // 0x00000020
-    Showcase           = 256,    // 0x00000100
-    HasBanner          = 512,    // 0x00000200
-    ShowViewButton     = 1024,   // 0x00000400
-    ShowMaxPurchases   = 2048,   // 0x00000800
-    ShowItemRarity     = 4096,   // 0x00001000
-    ShowItemType       = 8192,   // 0x00002000
-    CooldownTimerOn    = 16384,  // 0x00004000
-    ShowSynthetic      = 32768,  // 0x00008000
-    ShowPurchaseLimits = 65536,  // 0x00010000
-    ShowFreeTag        = 131072, // 0x00020000
-  };
-
-  ItemState CurrentState()
-  { return Field<"_currentState", ItemState>(); }
-
-  void AuxViewButtonPressedHandler()
-  { Call<"AuxViewButtonPressedHandler">(); }
-};
diff --git a/mods/src/prime/Button.h b/mods/src/prime/Button.h
deleted file mode 100644
index 2a25bdfdb..000000000
--- a/mods/src/prime/Button.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct Button : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.UI", "Button">;
-
-  void Press()
-  { Call<"Press">(); }
-};
diff --git a/mods/src/prime/ButtonAndContextWrapper.h b/mods/src/prime/ButtonAndContextWrapper.h
deleted file mode 100644
index 4e5cc5f44..000000000
--- a/mods/src/prime/ButtonAndContextWrapper.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include "GenericButtonWidget.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct ButtonAndContextWrapper : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "ButtonAndContextWrapper">;
-
-  GenericButtonWidget* Widget()
-  { return Field<"Widget", GenericButtonWidget*>(); }
-};
diff --git a/mods/src/prime/Camera.h b/mods/src/prime/Camera.h
deleted file mode 100644
index d260fc441..000000000
--- a/mods/src/prime/Camera.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-#include "Color.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct Camera : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Camera">;
-
-  float farClipPlane()
-  { return Get<"farClipPlane", float>(); }
-  void SetFarClipPlane(float value)
-  { Set<"farClipPlane">(value); }
-  float nearClipPlane()
-  { return Get<"nearClipPlane", float>(); }
-  void SetNearClipPlane(float value)
-  { Set<"nearClipPlane">(value); }
-  // UnityEngine.CameraClearFlags
-  int32_t clearFlags()
-  { return Get<"clearFlags", int32_t>(); }
-  void SetClearFlags(int32_t value)
-  { Set<"clearFlags">(value); }
-  color backgroundColor()
-  { return Get<"backgroundColor", color>(); }
-  void SetBackgroundColor(color value)
-  { Set<"backgroundColor">(value); }
-};
diff --git a/mods/src/prime/CanRepairRequirement.h b/mods/src/prime/CanRepairRequirement.h
deleted file mode 100644
index 7b599c7e3..000000000
--- a/mods/src/prime/CanRepairRequirement.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-#include "ActionRequirement.h"
-
-struct CanRepairRequirement : ActionRequirement {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models",
-                              "FleetPlayerData/CanRepairRequirement">;
-};
diff --git a/mods/src/prime/Canvas.h b/mods/src/prime/Canvas.h
deleted file mode 100644
index d2e7ebb8f..000000000
--- a/mods/src/prime/Canvas.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct Canvas : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.UIModule", "UnityEngine", "Canvas">;
-
-  float scaleFactor()
-  { return Get<"scaleFactor", float>(); }
-  void SetScaleFactor(float value)
-  { Set<"scaleFactor">(value); }
-};
diff --git a/mods/src/prime/CanvasController.h b/mods/src/prime/CanvasController.h
deleted file mode 100644
index 51052a545..000000000
--- a/mods/src/prime/CanvasController.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-#include "Canvas.h"
-#include "Transform.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct CanvasController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "CanvasController">;
-
-  bool ResetFocus()
-  { return Call<"ResetFocus", bool>(); }
-  bool Visible()
-  { return Get<"Visible", bool>(); }
-  // The bound data context, of the class the canvas's view expects.
-  il2cpp::Object* Context()
-  { return Get<"Context", il2cpp::Object*>(); }
-  bool get_enabled()
-  { return Get<"enabled", bool>(); }
-  bool m_Visible()
-  { return Field<"m_visible", bool>(); }
-
-  Il2CppString* name()
-  { return Get<"name", Il2CppString*>(); }
-  Transform* transform()
-  { return Get<"transform", Transform*>(); }
-  Canvas* canvas()
-  { return Field<"m_canvas", Canvas*>(); }
-};
-
-inline CanvasController* GetCanvasControllerFromComponent(il2cpp::Object* component)
-{
-  if (!component)
-    return nullptr;
-  // Passing System.Type selects GetComponentInParent(Type) over the generic overload.
-  return component->Call<"GetComponentInParent", CanvasController*>(CanvasController::Class::TypeObject());
-}
diff --git a/mods/src/prime/CanvasScaler.h b/mods/src/prime/CanvasScaler.h
deleted file mode 100644
index ae839dfef..000000000
--- a/mods/src/prime/CanvasScaler.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-
-#include "Vector2.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct CanvasScaler : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.UI", "CanvasScaler">;
-
-  // Writes Canvas.scaleFactor directly. The scaleFactor property is only applied on the scaler's next Update.
-  void SetScaleFactor(float value)
-  { Call<"SetScaleFactor">(value); }
-
-  float scaleFactor()
-  { return Get<"scaleFactor", float>(); }
-  // Named after the managed setter because SetScaleFactor is the managed method above.
-  void set_scaleFactor(float value)
-  { Set<"scaleFactor">(value); }
-  vec2 referenceResolution()
-  { return Get<"referenceResolution", vec2>(); }
-  void SetReferenceResolution(vec2 value)
-  { Set<"referenceResolution">(value); }
-};
diff --git a/mods/src/prime/CelestialObjectViewerWidget.h b/mods/src/prime/CelestialObjectViewerWidget.h
deleted file mode 100644
index 9b41638b4..000000000
--- a/mods/src/prime/CelestialObjectViewerWidget.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include "ObjectViewerBaseWidget.h"
-
-struct CelestialObjectViewerWidget : ObjectViewerBaseWidget {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "CelestialObjectViewerWidget">;
-};
diff --git a/mods/src/prime/ChatManager.h b/mods/src/prime/ChatManager.h
deleted file mode 100644
index df7006ded..000000000
--- a/mods/src/prime/ChatManager.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-#include "MonoSingleton.h"
-
-#include <il2cpp/il2cpp.h>
-
-enum class ChatChannelCategory : int32_t {
-  None            = -1,
-  Newbie          = 0,
-  Global          = 1,
-  Alliance        = 2,
-  Private         = 3,
-  Private_Message = 4,
-  Block           = 5,
-  Regional        = 6,
-};
-
-enum class ChatViewMode : int32_t {
-  Fullscreen = 0,
-  Side       = 1,
-};
-
-struct ChatManager : MonoSingleton<ChatManager> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Chat", "ChatManager">;
-
-  void OpenChannel(ChatChannelCategory category = ChatChannelCategory::Alliance)
-  { Call<"OpenChannel">(category, il2cpp_string_new("")); }
-
-  void OpenChannel(ChatChannelCategory category, ChatViewMode viewMode)
-  {
-    SetViewMode(viewMode);
-    OpenChannel(category);
-  }
-
-  bool CanSeeNewbieChat()
-  { return Call<"CanSeeNewbieChat", bool>(); }
-  bool CanSeeRegionalChat()
-  { return Call<"CanSeeRegionalChat", bool>(); }
-
-  bool IsSideChatAllowed()
-  { return Get<"IsSideChatAllowed", bool>(); }
-  bool IsSideChatOpen()
-  { return Get<"IsSideChatOpen", bool>(); }
-  bool isContextInitialised()
-  { return Field<"_isContextInitialised", bool>(); }
-  ChatViewMode ViewMode()
-  { return Get<"ViewMode", ChatViewMode>(); }
-  void SetViewMode(ChatViewMode value)
-  { Set<"ViewMode">(value); }
-};
diff --git a/mods/src/prime/ChatMessageListLocalViewController.h b/mods/src/prime/ChatMessageListLocalViewController.h
deleted file mode 100644
index ee2fb7d16..000000000
--- a/mods/src/prime/ChatMessageListLocalViewController.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-
-#include "ChatManager.h"
-#include "TMP_InputField.h"
-#include "ViewController.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct ChatSectionContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Chat", "ChatSectionContext">;
-
-  ChatChannelCategory category()
-  { return Field<"_category", ChatChannelCategory>(); }
-};
-
-struct ChatMessageListLocalViewController : ViewController<ChatSectionContext> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Chat", "ChatMessageListLocalViewController">;
-
-  TMP_InputField* inputField()
-  { return Field<"_inputField", TMP_InputField*>(); }
-  bool inputFieldSelected()
-  { return Field<"_inputFieldSelected", bool>(); }
-};
diff --git a/mods/src/prime/ChatMessageWidget.h b/mods/src/prime/ChatMessageWidget.h
deleted file mode 100644
index 1f61620e4..000000000
--- a/mods/src/prime/ChatMessageWidget.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-#include <il2cpp/il2cpp.h>
-#include "UserProfileWidget.h"
-struct ChatMessageWidget : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Chat", "ChatMessageWidget">;
-  UserProfileWidget* userProfileWidget()
-  { return Field<"_userProfileWidget", UserProfileWidget*>(); }
-};
diff --git a/mods/src/prime/ChatPreviewController.h b/mods/src/prime/ChatPreviewController.h
deleted file mode 100644
index 9d4938224..000000000
--- a/mods/src/prime/ChatPreviewController.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include "ChatManager.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct SwipeScroller : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "SwipeScroller">;
-
-  int32_t currentContentIndex()
-  { return Field<"_currentContentIndex", int32_t>(); }
-  void FocusOnInstantly(int32_t index)
-  { Call<"FocusOnInstantly">(index); }
-};
-
-struct ChatPreviewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Chat", "ChatPreviewController">;
-
-  // ImageSelector[]
-  il2cpp::Array<il2cpp::Object*>* panelIndicators()
-  { return Field<"_panelIndicators", il2cpp::Array<il2cpp::Object*>*>(); }
-  SwipeScroller* swipeScroller()
-  { return Field<"_swipeScroller", SwipeScroller*>(); }
-  ChatChannelCategory focusedPanel()
-  { return Field<"_focusedPanel", ChatChannelCategory>(); }
-  void SetFocusedPanel(ChatChannelCategory value)
-  { SetField<"_focusedPanel">(value); }
-  // Set by the game after its visibility refresh for a section change.
-  bool isSectionChangedCompleted()
-  { return Field<"_isSectionChangedCompleted", bool>(); }
-};
diff --git a/mods/src/prime/ClientModifierType.h b/mods/src/prime/ClientModifierType.h
deleted file mode 100644
index 9b10a38ca..000000000
--- a/mods/src/prime/ClientModifierType.h
+++ /dev/null
@@ -1,150 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-enum class ClientModifierType : int32_t {
-  Invalid                                 = -0x7FFF,
-  FleetOfficerBonusHealth                 = -17,
-  FleetOfficerBonusDefense                = -16,
-  FleetOfficerBonusAttack                 = -15,
-  FleetStrength                           = -14,
-  FleetOfficerRating                      = -13,
-  FleetSensorRating                       = -12,
-  FleetDeflectorRating                    = -11,
-  FleetHealthRating                       = -10,
-  FleetDefenseRating                      = -9,
-  FleetOffenseRating                      = -8,
-  FleetGrade                              = -7,
-  ShipShieldDamage                        = -6,
-  ShipHullDamage                          = -5,
-  FleetMiningBonus                        = -4,
-  ShipPlating                             = -3,
-  ShipAbsorption                          = -2,
-  ShipDamagePerRound                      = -1,
-  ModEnergyDamage                         = 0,
-  ModKineticDamage                        = 1,
-  ModAllDamage                            = 2,
-  ModShotsPerAttack                       = 3,
-  ModAllLoadSpeed                         = 4,
-  ModAllReloadSpeed                       = 5,
-  ModAccuracy                             = 6,
-  ModArmorPiercing                        = 7,
-  ModShieldPiercing                       = 8,
-  ModCritChance                           = 9,
-  ModCritDamage                           = 10,
-  ModShipDodge                            = 11,
-  ModShipArmor                            = 12,
-  ModShields                              = 13,
-  ModCptManeuverEffect                    = 14,
-  ModOffAbilityEffect                     = 15,
-  ModShieldHpRepair                       = 16,
-  ModHullHpRepair                         = 17,
-  ModAddState                             = 18,
-  ModRemoveState                          = 19,
-  ModParsteelProtection                   = 20,
-  ModTritaniumProtection                  = 21,
-  ModDilithiumProtection                  = 22,
-  ModCombatParsteelReward                 = 23,
-  ModCombatTritaniumReward                = 24,
-  ModCombatDilithiumReward                = 25,
-  ModCombatIntelReward                    = 26,
-  ModCombatLootDropChance                 = 27,
-  ModCombatLootDropQuantity               = 28,
-  ModCombatXpReward                       = 29,
-  ModMissionsParsteelReward               = 30,
-  ModMissionsTritaniumReward              = 31,
-  ModMissionsDilithiumReward              = 32,
-  ModMissionsIntelReward                  = 33,
-  ModMissionsLootDropChance               = 34,
-  ModMissionsLootDropQuantity             = 35,
-  ModMissionsXpReward                     = 36,
-  ModFactionPointsFederationReward        = 37,
-  ModFactionPointsKlingonReward           = 38,
-  ModFactionPointsRomulanReward           = 39,
-  ModFactionPointsAllReward               = 40,
-  ModMiningRateParsteel                   = 41,
-  ModMiningRateTritanium                  = 42,
-  ModMiningRateDilithium                  = 43,
-  ModMiningRateOre                        = 44,
-  ModMiningRateHydrocarbon                = 45,
-  ModMiningRewardParsteel                 = 46,
-  ModMiningRewardTritanium                = 47,
-  ModMiningRewardDilithium                = 48,
-  ModMiningRewardOre                      = 49,
-  ModMiningRewardHydrocarbon              = 50,
-  ModRepairCostsParsteel                  = 51,
-  ModRepairCostsTritanium                 = 52,
-  ModRepairCostsDilithium                 = 53,
-  ModRepairCostsAll                       = 54,
-  ModRepairTime                           = 55,
-  ModOfficerStatAttack                    = 56,
-  ModOfficerStatDefense                   = 57,
-  ModOfficerStatHealth                    = 58,
-  ModOfficerStatAll                       = 59,
-  ModShieldHpMax                          = 60,
-  ModHullHpMax                            = 61,
-  ModImpulseSpeed                         = 62,
-  ModWarpSpeed                            = 63,
-  ModWarpDistance                         = 64,
-  ModEnterWarpDelay                       = 65,
-  ModCargoCapacity                        = 66,
-  ModCargoProtection                      = 67,
-  ModAutoRecall                           = 68,
-  ModEnergyLoadSpeed                      = 69,
-  ModKineticLoadSpeed                     = 70,
-  ModEnergyReloadSpeed                    = 71,
-  ModKineticReloadSpeed                   = 72,
-  ModAllDefenses                          = 73,
-  ModAllPiercing                          = 74,
-  ModShieldRegenTime                      = 75,
-  ModShieldMitigation                     = 76,
-  ModResourceProtection                   = 100,
-  ModCombatResourceReward                 = 101,
-  ModMissionResourceReward                = 102,
-  ModFactionPointsRewards                 = 103,
-  ModFactionPointsLosses                  = 104,
-  ModMiningRate                           = 105,
-  ModMiningReward                         = 106,
-  ModRepairCosts                          = 107,
-  ModStarbaseModuleConstructionSpeed      = 108,
-  ModStarbaseModuleConstructionCost       = 109,
-  ModResearchSpeed                        = 110,
-  ModResearchCost                         = 111,
-  ModResourceGeneration                   = 112,
-  ModResourceStorage                      = 113,
-  ModForcefieldRechargeSpeed              = 114,
-  ModForcefieldHp                         = 115,
-  ModComponentCost                        = 116,
-  ModShipConstructionSpeed                = 117,
-  ModShipConstructionCost                 = 118,
-  ModTierUpSpeed                          = 119,
-  ModFactionPointsPenaltyRecution         = 120,
-  ModFactionStoreLootBonus                = 121,
-  ModOfficerLevelUpCost                   = 122,
-  ModOfficerPromoteCost                   = 123,
-  ModScanShip                             = 124,
-  ModScanStation                          = 125,
-  ModScanSystem                           = 126,
-  ModIncomingStationAttackInformation     = 127,
-  ModIncomingStationAttackAdvancedWarning = 128,
-  ModShipScrapResourceBonus               = 129,
-  ModShipScrapLootBonus                   = 130,
-  ModShipScrapSpeed                       = 131,
-  ModAwayMissionSpeed                     = 132,
-  ModAwayMissionResourceRewards           = 133,
-  ModAwayMissionLootBonus                 = 134,
-  ModResourceProducerResourceStorage      = 135,
-  ModWarehouseResourceStorage             = 136,
-  ModVaultResourceStorage                 = 137,
-  ModHullId                               = 138,
-  ModShipInventorySize                    = 139,
-  ModScanCost                             = 140,
-  ModTradeTax                             = 141,
-  ModRepairStation                        = 142,
-  ModArmadaSize                           = 143,
-  ModJumpAndTowCostEff                    = 147,
-  ModSkillCloakingCooldown                = 150,
-  ModSkillCloakingDuration                = 151,
-  ModSkillCloakingCost                    = 152,
-  ModSkillCloakingSneakChance             = 153
-};
\ No newline at end of file
diff --git a/mods/src/prime/Color.h b/mods/src/prime/Color.h
deleted file mode 100644
index faf533982..000000000
--- a/mods/src/prime/Color.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#pragma pack(push, 1)
-struct color {
-  float r, g, b, a;
-};
-#pragma pack(pop)
diff --git a/mods/src/prime/Component.h b/mods/src/prime/Component.h
deleted file mode 100644
index fc0f55df3..000000000
--- a/mods/src/prime/Component.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include "GameObject.h"
-#include "Transform.h"
-
-#include <il2cpp/il2cpp.h>
-
-// UnityEngine.Component, the base of every MonoBehaviour. Use As<Component>() on other bindings.
-struct Component : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Component">;
-
-  Transform* transform()
-  { return Get<"transform", Transform*>(); }
-  GameObject* gameObject()
-  { return Get<"gameObject", GameObject*>(); }
-};
diff --git a/mods/src/prime/CourseData.h b/mods/src/prime/CourseData.h
deleted file mode 100644
index 65fa5cfde..000000000
--- a/mods/src/prime/CourseData.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include "FleetPlayerData.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct CourseData : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "CourseData">;
-
-  FleetPlayerData* PlayerFleet()
-  { return Get<"PlayerFleet", FleetPlayerData*>(); }
-};
diff --git a/mods/src/prime/CoursePromptPopupWidget.h b/mods/src/prime/CoursePromptPopupWidget.h
deleted file mode 100644
index 8f1935004..000000000
--- a/mods/src/prime/CoursePromptPopupWidget.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-#include "CourseData.h"
-#include "GenericButtonWidget.h"
-#include "ViewController.h"
-#include "Widget.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct CoursePromptPopupDataContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "CoursePromptPopupDataContext">;
-
-  bool HasInstantWarp()
-  { return Field<"HasInstantWarp", bool>(); }
-  CourseData* GetCourseData()
-  { return Field<"CourseData", CourseData*>(); }
-};
-
-struct CoursePromptPopupWidget : Widget<CoursePromptPopupDataContext> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "CoursePromptPopupWidget">;
-
-  GenericButtonWidget* LeftButton()
-  { return Field<"_leftButton", GenericButtonWidget*>(); }
-  GenericButtonWidget* RightButton()
-  { return Field<"_rightButton", GenericButtonWidget*>(); }
-  void InitiateRegularWarp()
-  { Call<"InitiateRegularWarp">(); }
-  void OnInstantWarpButtonClick()
-  { Call<"OnInstantWarpButtonClick">(); }
-};
-
-struct CoursePromptPopupViewController : ViewController<CoursePromptPopupDataContext> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "CoursePromptPopupViewController">;
-
-  CoursePromptPopupWidget* PopupWidget()
-  { return Field<"_coursePromptPopupWidget", CoursePromptPopupWidget*>(); }
-};
diff --git a/mods/src/prime/DeploymentManager.h b/mods/src/prime/DeploymentManager.h
deleted file mode 100644
index 188acb2f7..000000000
--- a/mods/src/prime/DeploymentManager.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-#include "FleetDeployedData.h"
-#include "FleetPlayerData.h"
-#include "MonoSingleton.h"
-#include "Vector3.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct DeploymentService : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "DeploymentService">;
-
-  // The compiler-generated <PlanCourse>d__N iterator. Unbound so MoveNext resolves on whatever class the game
-  // returns; the suffix changes between client builds.
-  struct IEnumerator_PlanCourse : il2cpp::Object {
-    bool MoveNext()
-    { return Call<"MoveNext", bool>(); }
-  };
-};
-
-// The managed class is DeploymentManager; the misspelled C++ name is kept for existing callers.
-struct DeploymentManger : MonoSingleton<DeploymentManger> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "", "DeploymentManager">;
-
-  void SetTowRequest(uint64_t towedFleetId, uint64_t towingFleetId)
-  {
-    // The game expects a CallbackContainer<int>; an empty one without handlers is enough. Take the concrete
-    // generic instance from the method signature instead of spelling the inflated class out here.
-    static Il2CppClass* const callback_class = [] {
-      auto method = Class::Method("SetTowRequest", 3);
-      return method ? il2cpp_class_from_type(method.Info()->parameters[2]) : nullptr;
-    }();
-    if (!callback_class)
-      return;
-    Call<"SetTowRequest">(towedFleetId, towingFleetId, il2cpp_object_new(callback_class));
-  }
-
-  bool HasInstantWarpAbility(FleetPlayerData* selectedFleet)
-  { return Call<"HasInstantWarpAbility", bool>(selectedFleet); }
-
-  // targetAddress is a NodeAddress; the trailing data arguments are optional references.
-  DeploymentService::IEnumerator_PlanCourse* PlanCourse(FleetPlayerData* selectedFleet, void* targetAddress,
-                                                        Vector3 targetPosition, FleetDeployedData* targetDeployedFleet,
-                                                        void* starbaseData, void* allianceStarbaseData,
-                                                        void* outpost = nullptr)
-  {
-    return Call<"PlanCourse", DeploymentService::IEnumerator_PlanCourse*>(
-        selectedFleet, targetAddress, targetPosition, targetDeployedFleet, starbaseData, allianceStarbaseData, outpost);
-  }
-};
diff --git a/mods/src/prime/ElementSelectorViewController.h b/mods/src/prime/ElementSelectorViewController.h
deleted file mode 100644
index 0daefee5a..000000000
--- a/mods/src/prime/ElementSelectorViewController.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#pragma once
-
-#include "Button.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct ElementSelectorViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.UI", "ElementSelectorViewController">;
-
-  Button* decrementButton()
-  { return Field<"_decrementButton", Button*>(); }
-  Button* incrementButton()
-  { return Field<"_incrementButton", Button*>(); }
-
-  // Unity's internal call, so a missing binding never hides the selector hotkeys.
-  bool isActiveAndEnabled()
-  {
-    static auto get_isActiveAndEnabled =
-        il2cpp::ResolveICall<bool(ElementSelectorViewController*)>("UnityEngine.Behaviour::get_isActiveAndEnabled()");
-    if (get_isActiveAndEnabled) {
-      return get_isActiveAndEnabled(this);
-    }
-    return true;
-  }
-
-  void Decrement()
-  { Call<"Decrement">(); }
-  void Increment()
-  { Call<"Increment">(); }
-
-  void PressDecrement()
-  {
-    if (auto btn = decrementButton()) {
-      btn->Press();
-    }
-  }
-
-  void PressIncrement()
-  {
-    if (auto btn = incrementButton()) {
-      btn->Press();
-    }
-  }
-};
diff --git a/mods/src/prime/EmbassyObjectViewer.h b/mods/src/prime/EmbassyObjectViewer.h
deleted file mode 100644
index e96af1e77..000000000
--- a/mods/src/prime/EmbassyObjectViewer.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include "ObjectViewerBaseWidget.h"
-
-struct EmbassyObjectViewer : ObjectViewerBaseWidget {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "EmbassyObjectViewer">;
-};
diff --git a/mods/src/prime/EventSystem.h b/mods/src/prime/EventSystem.h
deleted file mode 100644
index bfa0d43cb..000000000
--- a/mods/src/prime/EventSystem.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include "GameObject.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct EventSystem : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.EventSystems", "EventSystem">;
-
-  static EventSystem* current()
-  { return Class::Get<"current", EventSystem*>(); }
-
-  GameObject* currentSelectedGameObject()
-  { return Get<"currentSelectedGameObject", GameObject*>(); }
-  void SetSelectedGameObject(GameObject* object)
-  { Call<"SetSelectedGameObject">(object); }
-};
diff --git a/mods/src/prime/FleetBarViewController.h b/mods/src/prime/FleetBarViewController.h
deleted file mode 100644
index f43a17004..000000000
--- a/mods/src/prime/FleetBarViewController.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include "FleetLocalViewController.h"
-#include "FleetPlayerData.h"
-#include "ViewController.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct FleetBarContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "FleetBarContext">;
-
-  il2cpp::Array<FleetPlayerData*>* FleetData()
-  { return Get<"FleetData", il2cpp::Array<FleetPlayerData*>*>(); }
-
-  FleetPlayerData* CurrentFleet()
-  { return Get<"CurrentFleet", FleetPlayerData*>(); }
-};
-
-struct FleetBarViewController : ViewController<FleetBarContext> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "FleetBarViewController">;
-
-  // The int overload; the other takes the list element Component.
-  void RequestSelect(int32_t index, bool simulated = false)
-  { Call<"RequestSelect">(index, simulated); }
-  bool IsIndexSelected(int32_t index)
-  { return Call<"IsIndexSelected", bool>(index); }
-
-  FleetLocalViewController* fleetPanelController()
-  { return Field<"_fleetPanelController", FleetLocalViewController*>(); }
-};
diff --git a/mods/src/prime/FleetDeployedData.h b/mods/src/prime/FleetDeployedData.h
deleted file mode 100644
index 7197c1143..000000000
--- a/mods/src/prime/FleetDeployedData.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include "HullSpec.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-enum class DeployedFleetType : int32_t {
-  Nonexistent,
-  Player,
-  Marauder,
-  NpcInstantiated,
-  Sentinel,
-  Alliance,
-  Challenge,
-};
-
-struct FleetDeployedData : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetDeployedData">;
-
-  int64_t ID()
-  { return Get<"ID", int64_t>(); }
-  HullSpec* Hull()
-  { return Get<"Hull", HullSpec*>(); }
-  // Nonexistent when the property is missing.
-  DeployedFleetType FleetType()
-  { return Get<"FleetType", DeployedFleetType>(); }
-};
diff --git a/mods/src/prime/FleetLiveData.h b/mods/src/prime/FleetLiveData.h
deleted file mode 100644
index 0fb21159b..000000000
--- a/mods/src/prime/FleetLiveData.h
+++ /dev/null
@@ -1,73 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-#include <optional>
-
-// Cargo, mining slot and timers off FleetPlayerData. The interfaces are bound as such: their getters dispatch to the
-// runtime class, which also covers FleetMiningSlot's explicit IMiningSlot implementation.
-
-// System.DateTime: ticks in the low 62 bits, the Kind in the top two.
-struct DateTime {
-  uint64_t dateData;
-
-  // Unix seconds, or empty for DateTime.MinValue (unset).
-  std::optional<int64_t> UnixSeconds() const
-  {
-    const auto ticks = static_cast<int64_t>(dateData & 0x3FFFFFFFFFFFFFFFull);
-    if (ticks <= 0)
-      return std::nullopt;
-    return (ticks - 621355968000000000LL) / 10000000LL;
-  }
-};
-
-// Concrete: ProgressData, CargoProgressData.
-struct IProgressData : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "IProgressData">;
-
-  double CurrentValue()
-  { return Get<"CurrentValue", double>(); }
-  double MaxValue()
-  { return Get<"MaxValue", double>(); }
-};
-
-struct CargoHoldData : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "CargoHoldData">;
-
-  IProgressData* CurrentCargo()
-  { return Get<"CurrentCargo", IProgressData*>(); }
-  IProgressData* ProtectedCargoProgress()
-  { return Get<"ProtectedCargoProgress", IProgressData*>(); }
-};
-
-struct IMiningNodeParams : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "IMiningNodeParams">;
-
-  int64_t Amount()
-  { return Get<"Amount", int64_t>(); }
-};
-
-// Concrete: FleetMiningSlot, MiningSlot.
-struct IMiningSlot : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "IMiningSlot">;
-
-  int64_t ParentId()
-  { return Get<"ParentId", int64_t>(); }
-  int64_t ResourceId()
-  { return Get<"ResourceId", int64_t>(); }
-  double AmountMined()
-  { return Get<"AmountMined", double>(); }
-  DateTime OccupyTimeUtc()
-  { return Get<"OccupyTimeUtc", DateTime>(); }
-  IMiningNodeParams* PointData()
-  { return Get<"PointData", IMiningNodeParams*>(); }
-};
-
-// Concrete: MiningSlotTimer and others.
-struct ITimerData : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "ITimerData">;
-
-  DateTime DueTime()
-  { return Get<"DueTime", DateTime>(); }
-};
diff --git a/mods/src/prime/FleetLocalViewController.h b/mods/src/prime/FleetLocalViewController.h
deleted file mode 100644
index fed1e224b..000000000
--- a/mods/src/prime/FleetLocalViewController.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include "ActionData.h"
-#include "ShipActionPanelLocalViewController.h"
-#include "FleetPlayerData.h"
-#include "ShipBarItemLocalViewController.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct FleetLocalViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "FleetLocalViewController">;
-
-  ShipActionPanelLocalViewController* shipActionPanelLocalViewController()
-  { return Field<"_shipActionPanelLocalViewController", ShipActionPanelLocalViewController*>(); }
-  FleetPlayerData* fleet()
-  { return Get<"fleet", FleetPlayerData*>(); }
-  ShipBarItemLocalViewController* shipBarItemLocalViewController()
-  { return Field<"_shipBarItemLocalViewController", ShipBarItemLocalViewController*>(); }
-
-  void CancelButtonClicked()
-  { Call<"CancelButtonClicked">(); }
-
-  // callback is an Action<bool, ActionBehaviour>; null is accepted.
-  bool RequestAction(IActionData target, ActionType type, int64_t index, ActionBehaviour behaviourMask,
-                     void* callback = nullptr)
-  { return Call<"RequestAction", bool>(target, type, index, behaviourMask, callback); }
-};
diff --git a/mods/src/prime/FleetMeshSelector.h b/mods/src/prime/FleetMeshSelector.h
deleted file mode 100644
index cd77a5afb..000000000
--- a/mods/src/prime/FleetMeshSelector.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include "GameObject.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct FleetMeshSelector : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "FleetMeshSelector">;
-
-  GameObject* LoadedObject()
-  { return Get<"LoadedObject", GameObject*>(); }
-};
diff --git a/mods/src/prime/FleetPlayerData.h b/mods/src/prime/FleetPlayerData.h
deleted file mode 100644
index 66340354b..000000000
--- a/mods/src/prime/FleetPlayerData.h
+++ /dev/null
@@ -1,147 +0,0 @@
-#pragma once
-
-#include "BattleTargetData.h"
-#include "HullSpec.h"
-#include "RecallRequirement.h"
-#include "CanRepairRequirement.h"
-#include "FleetLiveData.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-#include <optional>
-
-enum class FleetState : int32_t {
-  Unknown                = 0,
-  IdleInSpace            = 1,
-  Docked                 = 2,
-  Mining                 = 4,
-  Destroyed              = 8,
-  TieringUp              = 16,
-  CanReplaceOfficers     = 18,
-  Repairing              = 32,
-  CannotLaunch           = 56,
-  Battling               = 64,
-  WarpCharging           = 128,
-  Warping                = 256,
-  CanRemove              = 384,
-  Impulsing              = 512,
-  CanActivateAbility     = 513,
-  CanDisco               = 515,
-  Capturing              = 1024,
-  AutoHunting            = 2048,
-  CannotMove             = 2552,
-  CanManage              = 2947,
-  CanBeTargetedByAbility = 3589,
-  CanEngage              = 3591,
-  Outposting             = 4096,
-  CanRecall              = 5637,
-  Deployed               = 8133,
-  CanLocate              = 8135
-};
-
-struct FleetPlayerData : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetPlayerData">;
-
-  int32_t Index()
-  { return Get<"Index", int32_t>(); }
-  HullSpec* Hull()
-  { return Get<"Hull", HullSpec*>(); }
-  void* Address()
-  { return Get<"Address", void*>(); }
-  FleetState CurrentState()
-  { return Get<"CurrentState", FleetState>(); }
-  FleetState PreviousState()
-  { return Get<"PreviousState", FleetState>(); }
-  uint64_t Id()
-  { return Get<"Id", uint64_t>(); }
-  int64_t Level()
-  { return Get<"Level", int64_t>(); }
-  bool HasShip()
-  { return Get<"HasShip", bool>(); }
-  int64_t HullId()
-  { return Get<"HullId", int64_t>(); }
-  bool HasAppliedTech()
-  {
-    struct BaseShip : il2cpp::Object {
-      using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "BaseShip">;
-      int64_t Id()
-      { return Get<"Id", int64_t>(); }
-    };
-    struct Slot : il2cpp::Object {
-      using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "EntitySlot">;
-      int64_t SpecId()
-      { return Get<"SlotSpecId", int64_t>(); }
-      bool HasItem()
-      {
-        static const auto* getter = Class::Method("get_SlotItemId", 0).Info();
-        if (!getter || (getter->flags & METHOD_ATTRIBUTE_STATIC)
-            || getter->return_type->type != IL2CPP_TYPE_GENERICINST)
-          return false;
-        // Runtime invocation boxes Nullable<Int64> as null or its value, without assuming its native layout.
-        return il2cpp::detail::InvokeBoxed(getter, this, nullptr) != nullptr;
-      }
-    };
-    struct Manager : il2cpp::Object {
-      using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ForbiddenTechs", "ForbiddenTechManager">;
-      bool ActiveSlots(int64_t ship_id, il2cpp::List<Slot*>*& slots)
-      { return Call<"TryGetActiveForbiddenTechSlot", bool>(ship_id, std::ref(slots)); }
-    };
-    auto*                ship    = Get<"Ship", BaseShip*>();
-    auto*                manager = Manager::Class::Get<"Instance", Manager*>();
-    il2cpp::List<Slot*>* slots   = nullptr;
-    if (!ship || !manager || !manager->ActiveSlots(ship->Id(), slots) || !slots)
-      return false;
-    for (auto* slot : *slots) {
-      if (!slot)
-        continue;
-      const auto spec = slot->SpecId();
-      if ((spec == 3502081615 || spec == 953301906) && slot->HasItem())
-        return true;
-    }
-    return false;
-  }
-
-  // Live state, read for fleet sync.
-  bool IsHome()
-  { return Get<"IsHome", bool>(); }
-  bool IsDeployed()
-  { return Get<"IsDeployed", bool>(); }
-  bool IsMining()
-  { return Get<"IsMining", bool>(); }
-  bool IsRepairing()
-  { return Get<"IsRepairing", bool>(); }
-  bool IsDamaged()
-  { return Get<"IsDamaged", bool>(); }
-  bool IsDestroyed()
-  { return Get<"IsDestroyed", bool>(); }
-  int32_t DrydockID()
-  { return Get<"DrydockID", int32_t>(); }
-  float CargoResourceFillLevel()
-  { return Get<"CargoResourceFillLevel", float>(); }
-  CargoHoldData* CargoHold()
-  { return Get<"CargoHoldData", CargoHoldData*>(); }
-  IMiningSlot* MiningData()
-  { return Get<"MiningData", IMiningSlot*>(); }
-  ITimerData* Timer()
-  { return Get<"Timer", ITimerData*>(); }
-  // No property for the mining timer, so read the private field.
-  ITimerData* MiningSlotTimer()
-  { return Field<"_miningSlotTimer", ITimerData*>(); }
-  float GetMiningRate()
-  { return Call<"GetMiningRate", float>(); }
-  // Damage on the fleet's ship, so a docked ship's hull is known without the server. Empty without a ship.
-  std::optional<float> HullDamage()
-  {
-    // IShipModel, read on the ship's runtime class.
-    struct Ship : il2cpp::Object {
-      float HullDamage()
-      { return Get<"HullDamage", float>(); }
-    };
-    auto* ship = Get<"Ship", Ship*>();
-    return ship ? std::optional(ship->HullDamage()) : std::nullopt;
-  }
-
-  int64_t GetLocaId()
-  { return Call<"GetLocaId", int64_t>(); }
-};
diff --git a/mods/src/prime/FleetsManager.h b/mods/src/prime/FleetsManager.h
deleted file mode 100644
index 8a00a1c90..000000000
--- a/mods/src/prime/FleetsManager.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#pragma once
-
-#include "FleetDeployedData.h"
-#include "FleetPlayerData.h"
-#include "MonoSingleton.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct FleetsManager : MonoSingleton<FleetsManager> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.FleetManagement", "FleetsManager">;
-
-  void RequestViewFleet(FleetPlayerData* fleetData, bool showSystemInfo = false)
-  { Call<"RequestViewFleet">(fleetData, showSystemInfo); }
-
-  // The int overload takes a fleet slot; the long overload takes a fleet id.
-  FleetPlayerData* GetFleetPlayerData(int32_t idx)
-  { return Call<"GetFleetPlayerData", FleetPlayerData*>(idx); }
-
-  FleetPlayerData* GetSelectedFleetData()
-  { return Call<"GetSelectedFleetData", FleetPlayerData*>(); }
-
-  FleetDeployedData* targetFleetData()
-  { return Field<"_targetFleetData", FleetDeployedData*>(); }
-
-  // _fleetServiceCache is a CachedService<FleetService> struct whose HasService getter resolves and
-  // stores the service lazily. It has to run on the field in place, not on a boxed copy, so this
-  // stays on the raw runtime API.
-  bool HasFleetService()
-  {
-    static FieldInfo* const field = Class::Raw() ? il2cpp_class_get_field_from_name(Class::Raw(), "_fleetServiceCache")
-                                                 : nullptr;
-    static const MethodInfo* const has_service =
-        field ? il2cpp_class_get_method_from_name(il2cpp_class_from_type(il2cpp_field_get_type(field)),
-                                                  "get_HasService", 0)
-              : nullptr;
-    if (!has_service) {
-      return false;
-    }
-
-    auto* cache = reinterpret_cast<char*>(this) + il2cpp_field_get_offset(field);
-    if (*reinterpret_cast<void**>(cache)) {
-      return true;
-    }
-
-    Il2CppException* exception = nullptr;
-    auto*            result    = il2cpp_runtime_invoke(has_service, cache, nullptr, &exception);
-    return !exception && result && *static_cast<bool*>(il2cpp_object_unbox(result));
-  }
-};
diff --git a/mods/src/prime/FullScreenChatViewController.h b/mods/src/prime/FullScreenChatViewController.h
deleted file mode 100644
index 9a1687400..000000000
--- a/mods/src/prime/FullScreenChatViewController.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include "ChatMessageListLocalViewController.h"
-#include "TabBarViewController.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct FullScreenChatViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Chat", "FullScreenChatViewController">;
-
-  ChatMessageListLocalViewController* messageList()
-  { return Field<"_messageList", ChatMessageListLocalViewController*>(); }
-  TabBarViewController* categoriesTabBarViewController()
-  { return Field<"_categoriesTabBarViewController", TabBarViewController*>(); }
-};
diff --git a/mods/src/prime/GameObject.h b/mods/src/prime/GameObject.h
deleted file mode 100644
index 0d6febde7..000000000
--- a/mods/src/prime/GameObject.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-#include "str_utils.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <string>
-
-struct GameObject : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "GameObject">;
-
-  std::string Name()
-  {
-    auto* name = Get<"name", Il2CppString*>();
-    return name ? to_string(name) : std::string{};
-  }
-  bool activeInHierarchy()
-  { return Get<"activeInHierarchy", bool>(); }
-  void SetActive(bool active)
-  { Call<"SetActive">(active); }
-
-  // Passing System.Type selects the (Type) overloads over the string and generic ones. A null
-  // Type would throw in managed code, so a missing class yields null instead.
-  template <typename T> T* GetComponent()
-  {
-    auto* type = T::Class::TypeObject();
-    return type ? Call<"GetComponent", T*>(type) : nullptr;
-  }
-  template <typename T> T* AddComponent()
-  {
-    auto* type = T::Class::TypeObject();
-    return type ? Call<"AddComponent", T*>(type) : nullptr;
-  }
-};
diff --git a/mods/src/prime/GenericButtonContext.h b/mods/src/prime/GenericButtonContext.h
deleted file mode 100644
index b003b9b46..000000000
--- a/mods/src/prime/GenericButtonContext.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct GenericButtonContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "GenericButtonContext">;
-
-  bool Interactable()
-  { return Get<"Interactable", bool>(); }
-  void SetInteractable(bool value)
-  { Set<"Interactable">(value); }
-};
diff --git a/mods/src/prime/GenericButtonWidget.h b/mods/src/prime/GenericButtonWidget.h
deleted file mode 100644
index 87ade7771..000000000
--- a/mods/src/prime/GenericButtonWidget.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include "GenericButtonContext.h"
-#include "SemaphoreButtonListener.h"
-#include "TextLocalizer.h"
-#include "Widget.h"
-
-struct GenericButtonWidget : Widget<GenericButtonContext> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "GenericButtonWidget">;
-
-  SemaphoreButtonListener* SemaphoreListener()
-  { return Field<"_semaphoreButtonListener", SemaphoreButtonListener*>(); }
-  TextLocalizer* mainText()
-  { return Field<"_mainText", TextLocalizer*>(); }
-  bool Interactable()
-  { return Get<"Interactable", bool>(); }
-};
diff --git a/mods/src/prime/GenericRewardsScreenViewController.h b/mods/src/prime/GenericRewardsScreenViewController.h
deleted file mode 100644
index b3a33ed0a..000000000
--- a/mods/src/prime/GenericRewardsScreenViewController.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct GenericRewardsScreenViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.SharedFeatures", "GenericRewardsScreenViewController">;
-
-  void OnCollectClicked()
-  { Call<"OnCollectClicked">(); }
-  bool IsActive()
-  { return Call<"IsActive", bool>(); }
-};
diff --git a/mods/src/prime/HousingObjectViewerWidget.h b/mods/src/prime/HousingObjectViewerWidget.h
deleted file mode 100644
index 1e21655f0..000000000
--- a/mods/src/prime/HousingObjectViewerWidget.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include "ObjectViewerBaseWidget.h"
-
-struct HousingObjectViewerWidget : ObjectViewerBaseWidget {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "HousingObjectViewerWidget">;
-};
diff --git a/mods/src/prime/HttpJob.h b/mods/src/prime/HttpJob.h
deleted file mode 100644
index efe7e2e27..000000000
--- a/mods/src/prime/HttpJob.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-
-#include "HttpRequest.h"
-#include "UnityWebRequest.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-enum class HttpJobState : int32_t {
-  None                 = 0,
-  Queued               = 1,
-  RequestSending       = 2,
-  ResponseReceiving    = 3,
-  ResponseReceived     = 4,
-  ResponseBuilt        = 5,
-  WaitForAsyncCallback = 6,
-  Complete             = 7
-};
-
-struct HttpJob : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Engine.HttpClient.Runtime", "Digit.Engine.HttpClient", "HttpJob">;
-
-  HttpRequest* Request()
-  { return Field<"Request", HttpRequest*>(); }
-  UnityWebRequest* UnityRequest()
-  { return Field<"UnityRequest", UnityWebRequest*>(); }
-  HttpJobState State()
-  { return Field<"State", HttpJobState>(); }
-  // Writes the field directly and bypasses the managed SetState(HttpJobState).
-  void SetState(HttpJobState state)
-  { SetField<"State">(state); }
-};
diff --git a/mods/src/prime/HttpRequest.h b/mods/src/prime/HttpRequest.h
deleted file mode 100644
index 207afa2c5..000000000
--- a/mods/src/prime/HttpRequest.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct HttpRequest : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Engine.HttpClient.Runtime", "Digit.Engine.HttpClient", "HttpRequest">;
-
-  const Il2CppChar* get_URL()
-  {
-    auto* url = Get<"URL", Il2CppString*>();
-    return url ? il2cpp_string_chars(url) : nullptr;
-  }
-};
diff --git a/mods/src/prime/HttpResponse.h b/mods/src/prime/HttpResponse.h
deleted file mode 100644
index c0515c04f..000000000
--- a/mods/src/prime/HttpResponse.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include "HttpRequest.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct HttpResponse : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Engine.HttpClient.Runtime", "Digit.Engine.HttpClient", "HttpResponse">;
-
-  HttpRequest* get_Request()
-  { return Get<"Request", HttpRequest*>(); }
-  Il2CppString* Body()
-  { return Get<"Body", Il2CppString*>(); }
-};
diff --git a/mods/src/prime/Hub.h b/mods/src/prime/Hub.h
index d4ab5612a..1a2b442e6 100644
--- a/mods/src/prime/Hub.h
+++ b/mods/src/prime/Hub.h
@@ -1,8 +1,12 @@
 #pragma once
 
+// The game as an application: its section (screen) state, the Hub of services, the app itself and its config, and
+// the services the mod touches that belong to no screen (tutorial gates, audio, the Windows window procedure).
+
 #include <il2cpp/il2cpp.h>
 
 #include <cstdint>
+#include <optional>
 
 enum class SectionID : int32_t {
   ArtifactHall_Inventory                   = -2058246328,
@@ -152,13 +156,6 @@ struct SectionStorage : il2cpp::Object {
   { return Call<"GetState", void*>(section); }
 };
 
-struct SectionNavHistory : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Sections", "SectionNavHistory">;
-
-  bool Contains(SectionID section)
-  { return Call<"ContainsSectionID", bool>(section); }
-};
-
 struct SectionManager : il2cpp::Object {
   using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Sections", "SectionManager">;
 
@@ -166,22 +163,15 @@ struct SectionManager : il2cpp::Object {
   { return Get<"CurrentSection", SectionID>(); }
   SectionStorage* sectionStorage()
   { return Field<"_sectionStorage", SectionStorage*>(); }
-  SectionNavHistory* history()
-  { return Field<"_history", SectionNavHistory*>(); }
 
   // The (SectionData) overload is not used here; args is any managed object or null.
   bool TriggerSectionChange(SectionID nextSectionID, void* args, bool forcedSectionChange = false,
                             bool isGoBackStep = false, bool allowSameSection = false)
   {
-    return Call<"TriggerSectionChange", bool>(nextSectionID, args, forcedSectionChange, isGoBackStep,
-                                              allowSameSection);
+    return Call<"TriggerSectionChange", bool>(nextSectionID, args, forcedSectionChange, isGoBackStep, allowSameSection);
   }
 };
 
-struct GSServiceRegistry : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.Networking.Core", "GSServiceRegistry">;
-};
-
 // Digit.Client.Core.CustomReloadArgs and Nullable<CustomReloadArgs>, laid out as the runtime does.
 struct CustomReloadArgs {
   Il2CppObject* SectionArgs;
@@ -199,30 +189,93 @@ struct PrimeApp : il2cpp::Object {
   { Call<"Quit">(); }
   void Reload()
   { Call<"Reload">(false, NullableCustomReloadArgs{}, false); }
-  GSServiceRegistry* get_Services()
-  { return Get<"Services", GSServiceRegistry*>(); }
+};
+
+struct AppConfig : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Core", "AppConfig">;
+
+  void SetPlatformSettingsUrl(Il2CppString* value)
+  { Set<"PlatformSettingsUrl">(value); }
+  void SetAssetUrlOverride(Il2CppString* value)
+  { Set<"AssetUrlOverride">(value); }
+};
+
+// Loads the app config at startup.
+struct Model : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Core", "Model">;
+
+  AppConfig* appConfig()
+  { return Field<"_appConfig", AppConfig*>(); }
+};
+
+// Research progress. Its members resolve on the runtime class.
+struct ResearchManager : il2cpp::Object {
+  // Whether a visible research needs the resource. Empty when that could not be determined.
+  std::optional<bool> IsResourceRequiredByVisibleResearches(int64_t resource_id)
+  {
+    // Digit.PrimeServer.Models.ResearchTreeType; 0 is the main tree.
+    enum class ResearchTreeType : int32_t {};
+    return TryCall<"IsResourceRequiredByVisibleResearches", bool(int64_t, ResearchTreeType)>(resource_id,
+                                                                                             ResearchTreeType{});
+  }
+};
+
+struct TutorialManager : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Tutorial", "TutorialManager">;
+
+  bool IsSceneInputAllowed()
+  { return Call<"IsSceneInputAllowed", bool>(); }
 };
 
 // Digit.Client.Core.Hub is a static class.
 struct Hub {
   using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Core", "Hub">;
 
-  static SectionManager* get_SectionManager()
+  static SectionManager* Sections()
   { return Class::Get<"SectionManager", SectionManager*>(); }
-  static PrimeApp* get_App()
+  static PrimeApp* App()
   { return Class::Get<"App", PrimeApp*>(); }
+  static TutorialManager* Tutorial()
+  { return Class::Get<"TutorialManager", TutorialManager*>(); }
+  static ResearchManager* Research()
+  { return Class::Get<"ResearchManager", ResearchManager*>(); }
+
+  static SectionID CurrentSection()
+  {
+    auto* manager = Sections();
+    return manager ? manager->CurrentSection() : SectionID::AppInit;
+  }
+
+  static void GotoSection(SectionID section, void* data = nullptr)
+  {
+    if (auto* manager = Sections())
+      manager->TriggerSectionChange(section, data, false, false, true);
+  }
 
   static bool IsInChat()
   {
-    auto current_section = get_SectionManager()->CurrentSection();
-    return current_section == SectionID::Chat_Private_Message || current_section == SectionID::Chat_Alliance
-           || current_section == SectionID::Chat_Main || current_section == SectionID::Chat_Private_List;
+    const auto section = CurrentSection();
+    return section == SectionID::Chat_Private_Message || section == SectionID::Chat_Alliance
+           || section == SectionID::Chat_Main || section == SectionID::Chat_Private_List;
   }
 
   static bool IsInSystemOrGalaxyOrStarbase()
   {
-    auto current_section = get_SectionManager()->CurrentSection();
-    return current_section == SectionID::Navigation_Galaxy || current_section == SectionID::Navigation_System
-           || current_section == SectionID::Starbase_Interior || current_section == SectionID::Starbase_Exterior;
+    const auto section = CurrentSection();
+    return section == SectionID::Navigation_Galaxy || section == SectionID::Navigation_System
+           || section == SectionID::Starbase_Interior || section == SectionID::Starbase_Exterior;
   }
 };
+
+// Fabric.EventManager, the game's sound middleware. Its shorter PostEvent overloads funnel into the seven-argument
+// one.
+using AudioEventManager = il2cpp::Class<"Fabric.Core", "Fabric", "EventManager">;
+
+// Windows only: keeps the game window at its aspect ratio from Update and its own window procedure.
+struct AspectRatioConstraintHandler {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Utils", "AspectRatioConstraintHandler">;
+
+  // The window procedure Unity installed, which the handler's own procedure forwards to.
+  static void* unityWndProc()
+  { return reinterpret_cast<void*>(Class::Field<"_unityWndProc", intptr_t>()); }
+};
diff --git a/mods/src/prime/HullSpec.h b/mods/src/prime/HullSpec.h
deleted file mode 100644
index dae14687c..000000000
--- a/mods/src/prime/HullSpec.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-enum class HullType : int32_t {
-  Any          = -1,
-  Destroyer    = 0,
-  Survey       = 1,
-  Explorer     = 2,
-  Battleship   = 3,
-  Defense      = 4,
-  ArmadaTarget = 5
-};
-
-struct IdRefs : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "IdRefs">;
-
-  Il2CppString* locaStringId()
-  { return Field<"_locaStringId", Il2CppString*>(); }
-  int64_t locaId()
-  { return Field<"locaId_", int64_t>(); }
-};
-
-struct HullSpec : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "HullSpec">;
-
-  int64_t Id()
-  { return Field<"id_", int64_t>(); }
-  Il2CppString* Name()
-  { return Field<"name_", Il2CppString*>(); }
-  Il2CppString* IdStr()
-  { return Field<"idStr_", Il2CppString*>(); }
-  HullType Type()
-  { return Get<"Type", HullType>(); }
-  IdRefs* idRefs()
-  { return Field<"idRefs_", IdRefs*>(); }
-};
diff --git a/mods/src/prime/IBuffComparer.h b/mods/src/prime/IBuffComparer.h
deleted file mode 100644
index 46a81981a..000000000
--- a/mods/src/prime/IBuffComparer.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-// Interface binding; the getters dispatch to the receiver's implementation.
-struct IBuffComparer : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "IBuffComparer">;
-
-  int64_t get_HullId()
-  { return Get<"HullID", int64_t>(); }
-  int64_t get_FactionId()
-  { return Get<"FactionID", int64_t>(); }
-};
diff --git a/mods/src/prime/IBuffData.h b/mods/src/prime/IBuffData.h
deleted file mode 100644
index 3c1c64212..000000000
--- a/mods/src/prime/IBuffData.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include "ClientModifierType.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct IBuffData : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit", "IBuffData">;
-
-  ClientModifierType ModifierType()
-  { return Get<"ModifierType", ClientModifierType>(); }
-};
diff --git a/mods/src/prime/IEnumerator.h b/mods/src/prime/IEnumerator.h
deleted file mode 100644
index fc2c54dda..000000000
--- a/mods/src/prime/IEnumerator.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct IEnumerator : il2cpp::Object {
-};
diff --git a/mods/src/prime/Image.h b/mods/src/prime/Image.h
deleted file mode 100644
index fba0a1c9a..000000000
--- a/mods/src/prime/Image.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-#include "Color.h"
-#include "Component.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct Sprite : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Sprite">;
-
-  float pixelsPerUnit()
-  { return Get<"pixelsPerUnit", float>(); }
-};
-
-// UnityEngine.UI.Image; color and raycastTarget come from Graphic.
-struct Image : Component {
-  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.UI", "Image">;
-
-  enum class Type : int32_t {
-    Simple = 0,
-    Sliced = 1,
-    Tiled  = 2,
-    Filled = 3,
-  };
-
-  Sprite* sprite()
-  { return Get<"sprite", Sprite*>(); }
-  void SetSprite(Sprite* value)
-  { Set<"sprite">(value); }
-  Sprite* overrideSprite()
-  { return Get<"overrideSprite", Sprite*>(); }
-  void SetOverrideSprite(Sprite* value)
-  { Set<"overrideSprite">(value); }
-  void SetType(Type value)
-  { Set<"type">(value); }
-  void SetPreserveAspect(bool value)
-  { Set<"preserveAspect">(value); }
-  void SetPixelsPerUnitMultiplier(float value)
-  { Set<"pixelsPerUnitMultiplier">(value); }
-  void SetColor(color value)
-  { Set<"color">(value); }
-  void SetRaycastTarget(bool value)
-  { Set<"raycastTarget">(value); }
-  void SetVerticesDirty()
-  { Call<"SetVerticesDirty">(); }
-};
diff --git a/mods/src/prime/InputFieldWidget.h b/mods/src/prime/InputFieldWidget.h
deleted file mode 100644
index d8d16e554..000000000
--- a/mods/src/prime/InputFieldWidget.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include "TMP_InputField.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct InputFieldWidget : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "InputFieldWidget">;
-
-  void Focus()
-  { Call<"Focus">(); }
-
-  TMP_InputField* input()
-  { return Field<"_input", TMP_InputField*>(); }
-  bool isActiveAndEnabled()
-  { return Get<"isActiveAndEnabled", bool>(); }
-};
diff --git a/mods/src/prime/InterstitialViewController.h b/mods/src/prime/InterstitialViewController.h
deleted file mode 100644
index b6f17e474..000000000
--- a/mods/src/prime/InterstitialViewController.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct InterstitialViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Interstitial", "InterstitialViewController">;
-
-  void CloseWhenReady()
-  { Call<"CloseWhenReady">(); }
-};
diff --git a/mods/src/prime/InventoryForPopup.h b/mods/src/prime/InventoryForPopup.h
deleted file mode 100644
index e1258d63e..000000000
--- a/mods/src/prime/InventoryForPopup.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct InventoryForPopup : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Inventories", "InventoryForPopup">;
-
-  int64_t MaxItemsToUse()
-  { return Get<"MaxItemsToUse", int64_t>(); }
-  void SetMaxItemsToUse(int64_t value)
-  { Set<"MaxItemsToUse">(value); }
-  bool IsDonationUse()
-  { return Get<"IsDonationUse", bool>(); }
-  void SetIsDonationUse(bool value)
-  { Set<"IsDonationUse">(value); }
-  bool IsChestPurchase()
-  { return Get<"IsChestPurchase", bool>(); }
-};
diff --git a/mods/src/prime/InventoryListViewController.h b/mods/src/prime/InventoryListViewController.h
deleted file mode 100644
index fdd353cd2..000000000
--- a/mods/src/prime/InventoryListViewController.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "CanvasController.h"
-#include "Hub.h"
-#include "InputFieldWidget.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct InventoryListViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Inventories", "InventoryListViewController">;
-
-  InputFieldWidget* inputField()
-  { return Field<"_inputField", InputFieldWidget*>(); }
-  SectionID targetSection()
-  { return Field<"_targetSection", SectionID>(); }
-  bool isActiveAndEnabled()
-  { return Get<"isActiveAndEnabled", bool>(); }
-  CanvasController* canvasController()
-  { return GetCanvasControllerFromComponent(this); }
-};
diff --git a/mods/src/prime/InventoryUseRowWidget.h b/mods/src/prime/InventoryUseRowWidget.h
deleted file mode 100644
index 5e9db5d2e..000000000
--- a/mods/src/prime/InventoryUseRowWidget.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-#include "InventoryForPopup.h"
-#include "Widget.h"
-
-struct InventoryUseRowWidget : Widget<InventoryForPopup> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Inventories", "InventoryUseRowWidget">;
-};
diff --git a/mods/src/prime/LanguageManager.h b/mods/src/prime/LanguageManager.h
deleted file mode 100644
index 339c2df18..000000000
--- a/mods/src/prime/LanguageManager.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "LocaleTextContext.h"
-#include "MonoSingleton.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct LanguageManager : MonoSingleton<LanguageManager> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Localization", "LanguageManager">;
-
-  bool TryGetTranslation(Il2CppString* category, int32_t key, Il2CppString** translatedText)
-  {
-    if (!translatedText)
-      return false;
-    return Call<"TryGetTranslation", bool(Il2CppString*, int32_t, Il2CppString*&)>(category, key, *translatedText);
-  }
-
-  bool Localize(Il2CppString*& translation, LocaleTextContext* context)
-  { return Call<"Localize", bool(Il2CppString*&, LocaleTextContext*)>(translation, context); }
-
-  static void ClearCache()
-  { Class::Call<"ClearCache">(); }
-};
diff --git a/mods/src/prime/LocaleTextContext.h b/mods/src/prime/LocaleTextContext.h
deleted file mode 100644
index 7d7fef4cc..000000000
--- a/mods/src/prime/LocaleTextContext.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-// Identifier + category pair that the localizer turns into display text.
-// Construct with il2cpp::New<LocaleTextContext>(identifier, category).
-struct LocaleTextContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "LocaleTextContext">;
-
-  // Fills the {N} slots of the identifier itself, e.g. "ship_name_{0}".
-  void ApplyIdentifierParameters(il2cpp::Array<Il2CppObject*>* parameters)
-  { Call<"ApplyIdentifierParameters">(parameters); }
-};
-
-struct LocaleUtilities {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Localization", "LocaleUtilities">;
-
-  static Il2CppString* Localize(LocaleTextContext* context, bool localizeTextParams = false,
-                                bool invariantCulture = false)
-  { return Class::Call<"Localize", Il2CppString*>(context, localizeTextParams, invariantCulture); }
-};
-
-struct Localizer {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Localization", "Localizer">;
-
-  // textCase is TextLocalizer.TextCase; 0 leaves the text as translated.
-  static Il2CppString* Localise(LocaleTextContext* context, bool forceCommas = false, int32_t textCase = 0)
-  { return Class::Call<"Localise", Il2CppString*>(context, forceCommas, textCase); }
-};
diff --git a/mods/src/prime/MiningObjectViewerWidget.h b/mods/src/prime/MiningObjectViewerWidget.h
deleted file mode 100644
index c9a9cd89f..000000000
--- a/mods/src/prime/MiningObjectViewerWidget.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-#include "ObjectViewerBaseWidget.h"
-#include "ScanEngageButtonsWidget.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-// MiningObjectViewerWidget.OccupiedState, a private nested enum.
-enum class OccupiedState : int32_t {
-  NotOccupied         = 0,
-  LocalPlayerOccupied = 1,
-  OtherPlayerOccupied = 2
-};
-
-struct MiningObjectViewerWidget : ObjectViewerBaseWidget {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "MiningObjectViewerWidget">;
-
-  void MineClicked()
-  { Call<"MineClicked">(); }
-
-  OccupiedState occupiedState()
-  { return Field<"_occupiedState", OccupiedState>(); }
-  ScanEngageButtonsWidget* scanEngageButtonsWidget()
-  { return Field<"_scanEngageButtonsWidget", ScanEngageButtonsWidget*>(); }
-};
diff --git a/mods/src/prime/MissionsObjectViewerWidget.h b/mods/src/prime/MissionsObjectViewerWidget.h
deleted file mode 100644
index f1c0b34e5..000000000
--- a/mods/src/prime/MissionsObjectViewerWidget.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include "ObjectViewerBaseWidget.h"
-
-struct MissionsObjectViewerWidget : ObjectViewerBaseWidget {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "MissionsObjectViewerWidget">;
-};
diff --git a/mods/src/prime/MonoSingleton.h b/mods/src/prime/MonoSingleton.h
deleted file mode 100644
index 0a592e4c1..000000000
--- a/mods/src/prime/MonoSingleton.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-// Unity singletons expose a static Instance on their MonoSingleton`1<T> base.
-template <typename T> struct MonoSingleton : il2cpp::Object {
-  static T* Instance()
-  { return T::Class::template Get<"Instance", T*>(); }
-  // The singleton s_instance already holds, or null. Instance can search the scene or create a replacement.
-  static T* Existing()
-  { return T::Class::template Field<"s_instance", T*>(); }
-};
diff --git a/mods/src/prime/NavigationFleetWidget.h b/mods/src/prime/NavigationFleetWidget.h
deleted file mode 100644
index b1c73cc16..000000000
--- a/mods/src/prime/NavigationFleetWidget.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include "FleetDeployedData.h"
-#include "NavigationLOD.h"
-#include "Widget.h"
-
-struct NavigationFleetWidget : Widget<FleetDeployedData> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationFleetWidget">;
-
-  NavigationLOD* lod()
-  { return Field<"_lod", NavigationLOD*>(); }
-};
diff --git a/mods/src/prime/NavigationInteractionUIContext.h b/mods/src/prime/NavigationInteractionUIContext.h
deleted file mode 100644
index 3a1b7c309..000000000
--- a/mods/src/prime/NavigationInteractionUIContext.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct NavigationInteractionUIContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationInteractionUIContext">;
-};
diff --git a/mods/src/prime/NavigationInteractionUIViewController.h b/mods/src/prime/NavigationInteractionUIViewController.h
deleted file mode 100644
index 7ea98bc27..000000000
--- a/mods/src/prime/NavigationInteractionUIViewController.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-#include "VisibilityController.h"
-#include "SemaphoreButtonListener.h"
-
-struct SetCourseWidget : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "SetCourseWidget">;
-  VisibilityController* visibilityController()
-  { return Field<"_visibilityController", VisibilityController*>(); }
-  bool isActiveAndEnabled()
-  { return Get<"isActiveAndEnabled", bool>(); }
-  SemaphoreButtonListener* joinWaveDefenseButton()
-  { return Field<"_joinWaveDefenseButton", SemaphoreButtonListener*>(); }
-};
-
-struct NavigationInteractionUIViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationInteractionUIViewController">;
-
-  bool TryPressJoinWaveDefense()
-  {
-    if (!IsSetCourseVisible()) {
-      return false;
-    }
-    auto* widget   = Field<"_setCourseWidget", SetCourseWidget*>();
-    auto* listener = widget ? widget->joinWaveDefenseButton() : nullptr;
-    if (!listener || !listener->isActiveAndEnabled()) {
-      return false;
-    }
-    // Button.Press preserves Unity's active/interactable checks and the native join callback.
-    if (auto* button = listener->TheButton()) {
-      button->Press();
-    }
-    return true;
-  }
-
-  bool IsSetCourseVisible()
-  {
-    auto* widget = Field<"_setCourseWidget", SetCourseWidget*>();
-    auto* visibility = widget ? widget->visibilityController() : nullptr;
-    return visibility && (visibility->state() == VisibilityState::Visible || visibility->state() == VisibilityState::Show)
-           && widget->isActiveAndEnabled();
-  }
-  void OnSetCourseButtonClick()
-  { Call<"OnSetCourseButtonClick">(); }
-};
diff --git a/mods/src/prime/NavigationLOD.h b/mods/src/prime/NavigationLOD.h
deleted file mode 100644
index 5ce0f5a73..000000000
--- a/mods/src/prime/NavigationLOD.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include "ZoomLevels.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct NavigationLOD : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationLOD">;
-
-  void UpdateLOD(ZoomLevels level)
-  { Call<"UpdateLOD">(level); }
-
-  // Writes the backing field directly; the managed setter is private.
-  void SetTargetLevel(ZoomLevels level)
-  { SetField<"<TargetLevel>k__BackingField">(level); }
-};
diff --git a/mods/src/prime/NavigationManager.h b/mods/src/prime/NavigationManager.h
deleted file mode 100644
index 96ac794f5..000000000
--- a/mods/src/prime/NavigationManager.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct NavigationManager : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationManager">;
-
-  void HideInteraction()
-  { Call<"HideInteraction">(); }
-};
diff --git a/mods/src/prime/NavigationPan.h b/mods/src/prime/NavigationPan.h
deleted file mode 100644
index de5a1f119..000000000
--- a/mods/src/prime/NavigationPan.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-#include "Vector2.h"
-
-#include <il2cpp/il2cpp.h>
-
-#pragma pack(push, 1)
-struct vec3 {
-  float x, y, z;
-};
-#pragma pack(pop)
-
-struct NavigationPan : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationPan">;
-
-  void MoveCamera(vec2 delta, bool isMomentum = false)
-  { Call<"MoveCamera">(delta, isMomentum); }
-
-  static bool BlockPan()
-  { return Class::Field<"BlockPan", bool>(); }
-
-  Vector2 lastDelta()
-  { return Field<"_lastDelta", Vector2>(); }
-  void SetLastDelta(Vector2 value)
-  { SetField<"_lastDelta">(value); }
-  bool panningStarted()
-  { return Field<"_panningStarted", bool>(); }
-  float deltaScaler()
-  { return Field<"_deltaScaler", float>(); }
-  float keyboardDeltaScaler()
-  { return Field<"_keyboardDeltaScaler", float>(); }
-  // Managed POI; only checked for null or cleared.
-  void* trackingPOI()
-  { return Field<"_trackingPOI", void*>(); }
-  void SetTrackingPOI(void* value)
-  { SetField<"_trackingPOI">(value); }
-
-  float farMagRadiusRatioSystemNormal()
-  { return Field<"_farMagRadiusRatioSystemNormal", float>(); }
-  void SetFarMagRadiusRatioSystemNormal(float value)
-  { SetField<"_farMagRadiusRatioSystemNormal">(value); }
-  float farMagRadiusRatioSystemExtended()
-  { return Field<"_farMagRadiusRatioSystemExtended", float>(); }
-  void SetFarMagRadiusRatioSystemExtended(float value)
-  { SetField<"_farMagRadiusRatioSystemExtended">(value); }
-  float nearMagRadiusRatioSystem()
-  { return Field<"_nearMagRadiusRatioSystemNormal", float>(); }
-};
diff --git a/mods/src/prime/NavigationSectionManager.h b/mods/src/prime/NavigationSectionManager.h
deleted file mode 100644
index d2b7dd4ba..000000000
--- a/mods/src/prime/NavigationSectionManager.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include "Hub.h"
-#include "NavigationManager.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct NavigationSectionManager : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationSectionManager">;
-
-  static void ChangeNavigationSection(SectionID sectionId, int64_t systemId = -1)
-  { Class::Call<"ChangeNavigationSection">(sectionId, systemId); }
-
-  static NavigationSectionManager* Instance()
-  { return Class::Get<"Instance", NavigationSectionManager*>(); }
-
-  // Not NavigationManager(): that would hide the type inside this struct.
-  NavigationManager* SNavigationManager()
-  { return Get<"NavigationManager", NavigationManager*>(); }
-};
diff --git a/mods/src/prime/NavigationZoom.h b/mods/src/prime/NavigationZoom.h
deleted file mode 100644
index ed03a6d6f..000000000
--- a/mods/src/prime/NavigationZoom.h
+++ /dev/null
@@ -1,95 +0,0 @@
-#pragma once
-
-#include "Camera.h"
-#include "NavigationPan.h"
-#include "Vector2.h"
-#include "ZoomLevels.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-enum class NodeDepth : int32_t {
-  Galaxy       = 1,
-  SolarSystem  = 2,
-  PlanetSystem = 4,
-  Starbase     = 8,
-};
-
-struct NavigationZoom : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationZoom">;
-
-  void SetViewParameters(float radius, NodeDepth depth)
-  { Call<"SetViewParameters">(radius, depth); }
-  void ZoomCameraAtWorldPoint()
-  { Call<"ZoomCameraAtWorldPoint">(); }
-
-  float Distance()
-  { return Get<"Distance", float>(); }
-  void SetDistance(float value)
-  { Set<"Distance">(value); }
-  float NormalizedZoom()
-  { return Get<"NormalizedZoom", float>(); }
-
-  NodeDepth depth()
-  { return Field<"_depth", NodeDepth>(); }
-  void SetDepth(NodeDepth value)
-  { SetField<"_depth">(value); }
-  ZoomLevels zoomLevel()
-  { return Field<"_zoomLevel", ZoomLevels>(); }
-  Camera* sceneCamera()
-  { return Field<"_sceneCamera", Camera*>(); }
-
-  float storedZoomDistanceSystem()
-  { return Field<"_storedZoomDistanceSystem", float>(); }
-  void SetStoredZoomDistanceSystem(float value)
-  { SetField<"_storedZoomDistanceSystem">(value); }
-  float systemDefaultZoomRatio()
-  { return Field<"_systemDefaultZoomRatio", float>(); }
-  void SetSystemDefaultZoomRatio(float value)
-  { SetField<"_systemDefaultZoomRatio">(value); }
-  float actualDistance()
-  { return Field<"_actualDistance", float>(); }
-  void SetActualDistance(float value)
-  { SetField<"_actualDistance">(value); }
-  float zoomtotal()
-  { return Field<"_zoomtotal", float>(); }
-  void SetZoomtotal(float value)
-  { SetField<"_zoomtotal">(value); }
-  float minimum()
-  { return Field<"_minimum", float>(); }
-  void SetMinimum(float value)
-  { SetField<"_minimum">(value); }
-  float maximum()
-  { return Field<"_maximum", float>(); }
-  void SetMaximum(float value)
-  { SetField<"_maximum">(value); }
-  float zoomDelta()
-  { return Field<"_zoomDelta", float>(); }
-  void SetZoomDelta(float value)
-  { SetField<"_zoomDelta">(value); }
-  float viewRadius()
-  { return Field<"_viewRadius", float>(); }
-  void SetViewRadius(float value)
-  { SetField<"_viewRadius">(value); }
-  float lastZoomDelta()
-  { return Field<"_lastZoomDelta", float>(); }
-  void SetLastZoomDelta(float value)
-  { SetField<"_lastZoomDelta">(value); }
-  vec2 zoomLocation()
-  { return Field<"_zoomLocation", vec2>(); }
-  void SetZoomLocation(vec2 value)
-  { SetField<"_zoomLocation">(value); }
-  vec3 worldPoint()
-  { return Field<"_worldPoint", vec3>(); }
-  void SetWorldPoint(vec3 value)
-  { SetField<"_worldPoint">(value); }
-  float farRatioSystemNormal()
-  { return Field<"_farRatioSystemNormal", float>(); }
-  void SetFarRatioSystemNormal(float value)
-  { SetField<"_farRatioSystemNormal">(value); }
-  float farRatioSystemExtended()
-  { return Field<"_farRatioSystemExtended", float>(); }
-  void SetFarRatioSystemExtended(float value)
-  { SetField<"_farRatioSystemExtended">(value); }
-};
diff --git a/mods/src/prime/ObjectViewerBaseWidget.h b/mods/src/prime/ObjectViewerBaseWidget.h
deleted file mode 100644
index 35be10c32..000000000
--- a/mods/src/prime/ObjectViewerBaseWidget.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include "NavigationInteractionUIContext.h"
-#include "ParentObjectViewerViewController.h"
-#include "VisibilityController.h"
-#include "Widget.h"
-
-struct ObjectViewerBaseWidget : Widget<NavigationInteractionUIContext> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "ObjectViewerBaseWidget">;
-
-  void HideAllViewers()
-  { Call<"HideAllViewers">(); }
-
-  VisibilityController* visibilityController()
-  { return Field<"_visibilityController", VisibilityController*>(); }
-  ParentObjectViewerViewController* Parent()
-  { return Get<"Parent", ParentObjectViewerViewController*>(); }
-  bool IsInfoShown()
-  { return Get<"IsInfoShown", bool>(); }
-  void SetIsInfoShown(bool value)
-  { Set<"IsInfoShown">(value); }
-};
diff --git a/mods/src/prime/OfficerAssignmentViewController.h b/mods/src/prime/OfficerAssignmentViewController.h
deleted file mode 100644
index af5d3f875..000000000
--- a/mods/src/prime/OfficerAssignmentViewController.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "CanvasController.h"
-#include "GenericButtonWidget.h"
-#include "InputFieldWidget.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct OfficerAssignmentViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.OfficerAssignment", "OfficerAssignmentViewController">;
-
-  InputFieldWidget* inputField()
-  { return Field<"_inputField", InputFieldWidget*>(); }
-  GenericButtonWidget* officerPresetsButton()
-  { return Field<"_officerPresetsButton", GenericButtonWidget*>(); }
-  bool isActiveAndEnabled()
-  { return Get<"isActiveAndEnabled", bool>(); }
-  CanvasController* canvasController()
-  { return GetCanvasControllerFromComponent(this); }
-};
diff --git a/mods/src/prime/OrbitFrameProvider.h b/mods/src/prime/OrbitFrameProvider.h
deleted file mode 100644
index d12d4975f..000000000
--- a/mods/src/prime/OrbitFrameProvider.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct OrbitFrameProvider : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.CameraController", "OrbitFrameProvider">;
-
-  // Declared on AbstractOrbitFrameProvider.
-  float RotationAngleDelta()
-  { return Field<"_rotationAngleDelta", float>(); }
-  void SetRotationAngleDelta(float value)
-  { SetField<"_rotationAngleDelta">(value); }
-};
diff --git a/mods/src/prime/ParentObjectViewerViewController.h b/mods/src/prime/ParentObjectViewerViewController.h
deleted file mode 100644
index 867303b67..000000000
--- a/mods/src/prime/ParentObjectViewerViewController.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include "NavigationInteractionUIContext.h"
-#include "ViewController.h"
-#include "VisibilityController.h"
-
-struct ParentObjectViewerViewController : ViewController<NavigationInteractionUIContext> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "ParentObjectViewerViewController">;
-
-  void ActivateViewerHUDState(bool isHUDOpen = false)
-  { Call<"ActivateViewerHUDState">(isHUDOpen); }
-  void TriggerInstantHide()
-  { Call<"TriggerInstantHide">(); }
-  void TriggerShow()
-  { Call<"TriggerShow">(); }
-
-  VisibilityController* visibilityController()
-  { return Field<"_visibilityController", VisibilityController*>(); }
-  bool IsShowing()
-  { return Get<"IsShowing", bool>(); }
-};
diff --git a/mods/src/prime/PlanetViewUtils.h b/mods/src/prime/PlanetViewUtils.h
deleted file mode 100644
index bccde2892..000000000
--- a/mods/src/prime/PlanetViewUtils.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "PopulatedSystemData.h"
-#include "Transform.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct PlanetViewUtils : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "PlanetViewUtils">;
-
-  // Managed FlatRenderable. Calling this also runs any detour on get_FlatRenderable.
-  void* GetFlatRenderable()
-  { return Get<"FlatRenderable", void*>(); }
-
-  PopulatedSystemData* popData()
-  { return Field<"_popData", PopulatedSystemData*>(); }
-  Transform* activeSystemParent()
-  { return Field<"_activeSystemParent", Transform*>(); }
-};
diff --git a/mods/src/prime/PlanetaryBaseManager.h b/mods/src/prime/PlanetaryBaseManager.h
deleted file mode 100644
index 464c2fdd3..000000000
--- a/mods/src/prime/PlanetaryBaseManager.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-#include "Hub.h"
-#include "MonoSingleton.h"
-
-#include <il2cpp/il2cpp.h>
-
-// Older clients lack this class; there the binding logs it once and ViewOwnHaven does nothing.
-struct PlanetaryBaseManager : MonoSingleton<PlanetaryBaseManager> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.PlanetaryBase", "PlanetaryBaseManager">;
-
-  static void ViewOwnHaven()
-  {
-    auto* manager  = Instance();
-    auto* sections = Hub::get_SectionManager();
-    if (!manager || !sections)
-      return;
-
-    // Preserve the game's Iconian Gateway prerequisite and its locked-building message.
-    if (!manager->Call<"IsPlanetaryBaseCenterReady", bool>(true))
-      return;
-    // PlanetarySectionContext is reserved for visiting another player's Haven. Passing no context makes the
-    // PlanetarySectionDirector initialize the complete local Haven state from the service cache.
-    sections->TriggerSectionChange(SectionID::Starbase_Planetary, nullptr, false, false, true);
-  }
-};
diff --git a/mods/src/prime/PopulatedSystemData.h b/mods/src/prime/PopulatedSystemData.h
deleted file mode 100644
index 01a1bcedb..000000000
--- a/mods/src/prime/PopulatedSystemData.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct PopulatedSystemData : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "PopulatedSystemData">;
-
-  void* backdrop()
-  { return Field<"_backdrop", void*>(); }
-  int64_t systemId()
-  { return Field<"_systemId", int64_t>(); }
-};
diff --git a/mods/src/prime/PreScanStationTargetWidget.h b/mods/src/prime/PreScanStationTargetWidget.h
deleted file mode 100644
index 25991e3e9..000000000
--- a/mods/src/prime/PreScanStationTargetWidget.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include "PreScanTargetWidget.h"
-
-struct PreScanStationTargetWidget : PreScanTargetWidget {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Combat", "PreScanStationTargetWidget">;
-};
diff --git a/mods/src/prime/PreScanTargetWidget.h b/mods/src/prime/PreScanTargetWidget.h
deleted file mode 100644
index fbd30c253..000000000
--- a/mods/src/prime/PreScanTargetWidget.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-
-#include "BattleTargetData.h"
-#include "GenericButtonWidget.h"
-#include "ObjectViewerBaseWidget.h"
-#include "RewardsButtonWidget.h"
-#include "ScanEngageButtonsWidget.h"
-
-struct PreScanTargetWidget : ObjectViewerBaseWidget {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Combat", "PreScanTargetWidget">;
-
-  void ValidateThenCreateArmada()
-  { Call<"ValidateThenCreateArmada">(); }
-  void OnAddToQueueClickedEventHandler()
-  { Call<"OnAddToQueueClickedEventHandler">(); }
-  // Declared on ObjectViewerBaseWidget.
-  void OnInfoClick()
-  { Call<"OnInfoClick">(); }
-
-  BattleTargetData* battleTargetData()
-  { return Field<"_battleTargetData", BattleTargetData*>(); }
-  ScanEngageButtonsWidget* scanEngageButtonsWidget()
-  { return Field<"_scanEngageButtonsWidget", ScanEngageButtonsWidget*>(); }
-  RewardsButtonWidget* rewardsButtonWidget()
-  { return Field<"_rewardsButtonWidget", RewardsButtonWidget*>(); }
-  GenericButtonWidget* addToQueueButtonWidget()
-  { return Field<"_addToQueueButtonWidget", GenericButtonWidget*>(); }
-  GenericButtonWidget* armadaAttackButton()
-  { return Field<"_armadaAttackButton", GenericButtonWidget*>(); }
-};
diff --git a/mods/src/prime/RealtimeDataPayload.h b/mods/src/prime/RealtimeDataPayload.h
deleted file mode 100644
index e28e6ed13..000000000
--- a/mods/src/prime/RealtimeDataPayload.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-enum DataType : int32_t
-{
-  Unspecified = -1,
-  JSON = 0,
-  MsgPack = 1,
-  ProtoBuff = 2,
-  UrlEncoded = 3,
-};
-
-struct RealtimeDataPayload : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.Networking.RTC", "RealtimeDataPayload">;
-
-  // Managed DataType is a string, not the DataType enum above.
-  Il2CppString* DataType()
-  { return Get<"DataType", Il2CppString*>(); }
-  Il2CppString* ChannelId()
-  { return Get<"ChannelId", Il2CppString*>(); }
-  int32_t InstanceIdJson()
-  { return Get<"InstanceIdJson", int32_t>(); }
-  Il2CppString* Target()
-  { return Get<"Target", Il2CppString*>(); }
-  Il2CppString* Source()
-  { return Get<"Source", Il2CppString*>(); }
-  Il2CppString* Data()
-  { return Get<"Data", Il2CppString*>(); }
-};
diff --git a/mods/src/prime/RecallRequirement.h b/mods/src/prime/RecallRequirement.h
deleted file mode 100644
index f3afff55d..000000000
--- a/mods/src/prime/RecallRequirement.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-#include "ActionRequirement.h"
-
-struct RecallRequirement : ActionRequirement {
-  using Class =
-      il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetPlayerData/RecallRequirement">;
-};
diff --git a/mods/src/prime/RectTransform.h b/mods/src/prime/RectTransform.h
deleted file mode 100644
index 36a6f72c4..000000000
--- a/mods/src/prime/RectTransform.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-
-#include "Transform.h"
-#include "Vector2.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct RectTransform : Transform {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "RectTransform">;
-
-  Vector2 anchorMin()
-  { return Get<"anchorMin", Vector2>(); }
-  Vector2 anchorMax()
-  { return Get<"anchorMax", Vector2>(); }
-  Vector2 offsetMin()
-  { return Get<"offsetMin", Vector2>(); }
-  Vector2 offsetMax()
-  { return Get<"offsetMax", Vector2>(); }
-  void SetOffsetMin(Vector2 value)
-  { Set<"offsetMin">(value); }
-  void SetOffsetMax(Vector2 value)
-  { Set<"offsetMax">(value); }
-  void SetAnchorMin(Vector2 value)
-  { Set<"anchorMin">(value); }
-  void SetAnchorMax(Vector2 value)
-  { Set<"anchorMax">(value); }
-  void SetPivot(Vector2 value)
-  { Set<"pivot">(value); }
-  void SetSizeDelta(Vector2 value)
-  { Set<"sizeDelta">(value); }
-  void SetAnchoredPosition(Vector2 value)
-  { Set<"anchoredPosition">(value); }
-};
diff --git a/mods/src/prime/RewardsButtonWidget.h b/mods/src/prime/RewardsButtonWidget.h
deleted file mode 100644
index 982ef3d82..000000000
--- a/mods/src/prime/RewardsButtonWidget.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include "BattleTargetData.h"
-#include "VisibilityController.h"
-#include "Widget.h"
-
-struct RewardsButtonWidget : Widget<BattleTargetData> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Combat", "RewardsButtonWidget">;
-
-  void RewardsClicked()
-  { Call<"RewardsClicked">(); }
-
-  VisibilityController* rewardsController()
-  { return Field<"_rewardsController", VisibilityController*>(); }
-};
diff --git a/mods/src/prime/ScanEngageButtonsWidget.h b/mods/src/prime/ScanEngageButtonsWidget.h
deleted file mode 100644
index 7efd829c5..000000000
--- a/mods/src/prime/ScanEngageButtonsWidget.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "BattleTargetData.h"
-#include "GenericButtonWidget.h"
-#include "Widget.h"
-
-struct ScanEngageButtonsWidget : Widget<BattleTargetData> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Combat", "ScanEngageButtonsWidget">;
-
-  void OnArmadaButtonClicked()
-  { Call<"OnArmadaButtonClicked">(); }
-  void OnEngageButtonClicked()
-  { Call<"OnEngageButtonClicked">(); }
-  void OnScanButtonClicked()
-  { Call<"OnScanButtonClicked">(); }
-
-  GenericButtonWidget* armadaButton()
-  { return Field<"_armadaButton", GenericButtonWidget*>(); }
-};
diff --git a/mods/src/prime/ScanTargetViewController.h b/mods/src/prime/ScanTargetViewController.h
deleted file mode 100644
index e635482e6..000000000
--- a/mods/src/prime/ScanTargetViewController.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include "BattleTargetData.h"
-#include "ScanEngageButtonsWidget.h"
-#include "ViewController.h"
-
-struct ScanTargetViewController : ViewController<BattleTargetData> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Combat", "ScanTargetViewController">;
-
-  ScanEngageButtonsWidget* scanEngageButtonsWidget()
-  { return Field<"_scanEngageButtonsWidget", ScanEngageButtonsWidget*>(); }
-};
diff --git a/mods/src/prime/SceneArgs.h b/mods/src/prime/SceneArgs.h
deleted file mode 100644
index 366c4d21d..000000000
--- a/mods/src/prime/SceneArgs.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-
-class SceneArgs
-{
-};
\ No newline at end of file
diff --git a/mods/src/prime/SceneManager.h b/mods/src/prime/SceneManager.h
deleted file mode 100644
index 7c8dafaca..000000000
--- a/mods/src/prime/SceneManager.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-// Scene is a struct wrapping an int handle; the internal calls below take and fill it directly.
-struct SceneManager {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine.SceneManagement", "SceneManager">;
-
-  static const Il2CppChar* GetSceneName(void* scene)
-  {
-    static auto GetSceneName =
-        il2cpp::ResolveICall<Il2CppString*(void*)>("UnityEngine.SceneManagement.Scene::GetNameInternal(System.Int32)");
-    auto name = GetSceneName(scene);
-    return il2cpp_string_chars(name);
-  }
-
-  static void* GetActiveScene()
-  {
-    static auto GetActiveScene_Injected = il2cpp::ResolveICall<void(void*)>(
-        "UnityEngine.SceneManagement.SceneManager::GetActiveScene_Injected(UnityEngine.SceneManagement.Scene&)");
-    void* scene = nullptr;
-    GetActiveScene_Injected(&scene);
-    return scene;
-  }
-};
diff --git a/mods/src/prime/ScreenManager.h b/mods/src/prime/ScreenManager.h
deleted file mode 100644
index 6a5132fc9..000000000
--- a/mods/src/prime/ScreenManager.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include "CanvasController.h"
-#include "CanvasScaler.h"
-#include "MonoSingleton.h"
-
-struct UIFrameManager : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "UIFrameManager">;
-
-  // The game clamps the width to the available space and the side frame's minimum. False when the call failed.
-  bool ResizeSideFrame(float width)
-  { return TryCall<"ResizeSideFrame", void(float)>(width); }
-};
-
-struct ScreenManager : MonoSingleton<ScreenManager> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "ScreenManager">;
-
-  static CanvasController* GetTopCanvas(bool visibleOnly = false)
-  { return Class::Call<"GetTopCanvas", CanvasController*>(visibleOnly); }
-
-  // Every registered canvas, visible or not.
-  il2cpp::List<CanvasController*>* screens()
-  { return Field<"_screens", il2cpp::List<CanvasController*>*>(); }
-  CanvasScaler* canvasRootScaler()
-  { return Field<"m_canvasRootScaler", CanvasScaler*>(); }
-  float minimumCanvasScaleFactor()
-  { return Field<"_minimumCanvasScaleFactor", float>(); }
-  float maximumCanvasScaleFactor()
-  { return Field<"_maximumCanvasScaleFactor", float>(); }
-  UIFrameManager* frameManager()
-  { return Field<"_frameManager", UIFrameManager*>(); }
-};
diff --git a/mods/src/prime/SelectableList.h b/mods/src/prime/SelectableList.h
deleted file mode 100644
index 7de77238f..000000000
--- a/mods/src/prime/SelectableList.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-// Digit.Client.UI list hierarchy: BaseListContainer <- SelectableListBase <- SelectableList <- TabBar.
-// Data is a System.Collections.IList; elements are whatever the list was bound to.
-struct BaseListContainer : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "BaseListContainer">;
-
-  il2cpp::List<il2cpp::Object*>* data()
-  { return Field<"_data", il2cpp::List<il2cpp::Object*>*>(); }
-  int32_t Count()
-  { return Get<"Count", int32_t>(); }
-};
-
-struct SelectableList : BaseListContainer {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "SelectableList">;
-
-  int32_t SelectedIndex()
-  { return Get<"SelectedIndex", int32_t>(); }
-
-  // Declared on SelectableListBase. The int overload is picked over RequestSelect(Component, bool).
-  void RequestSelect(int32_t index, bool simulated = false)
-  { Call<"RequestSelect">(index, simulated); }
-
-  il2cpp::Object* DataItem(int32_t index)
-  {
-    auto* list = Get<"Data", il2cpp::List<il2cpp::Object*>*>();
-    return list ? (*list)[index] : nullptr;
-  }
-};
diff --git a/mods/src/prime/SemaphoreButtonListener.h b/mods/src/prime/SemaphoreButtonListener.h
deleted file mode 100644
index 8b29eb344..000000000
--- a/mods/src/prime/SemaphoreButtonListener.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include "Button.h"
-#include "SemaphoreListenerBase.h"
-
-struct SemaphoreButtonListener : SemaphoreListenerBase {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "SemaphoreButtonListener">;
-
-  Button* TheButton()
-  { return Field<"_button", Button*>(); }
-  bool Interactable()
-  { return Get<"Interactable", bool>(); }
-  bool isActiveAndEnabled()
-  { return Get<"isActiveAndEnabled", bool>(); }
-  void SetInteractable(bool value)
-  { Set<"Interactable">(value); }
-};
diff --git a/mods/src/prime/SemaphoreListenerBase.h b/mods/src/prime/SemaphoreListenerBase.h
deleted file mode 100644
index 13fc27052..000000000
--- a/mods/src/prime/SemaphoreListenerBase.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct SemaphoreListenerBase : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "SemaphoreListenerBase">;
-};
diff --git a/mods/src/prime/ServiceResponse.h b/mods/src/prime/ServiceResponse.h
deleted file mode 100644
index 8a9c289cd..000000000
--- a/mods/src/prime/ServiceResponse.h
+++ /dev/null
@@ -1,63 +0,0 @@
-#pragma once
-
-#include "EntityGroup.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct ServiceResponse : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "ServiceResponse">;
-
-  // Google.Protobuf.Collections.RepeatedField<EntityGroup>; List resolves Count/get_Item on it.
-  il2cpp::List<EntityGroup*>* EntityGroups()
-  { return Get<"EntityGroups", il2cpp::List<EntityGroup*>*>(); }
-};
-
-// The platform service's responses, Digit.Platform.Models. They pass through the same model registry code as game
-// server responses, but their entity groups have their own type enum.
-struct PlatformEntityGroup : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.Platform.Models", "EntityGroup">;
-
-  enum Type : int32_t {
-    StaticTranslations             = 0,
-    DynamicTranslations            = 1,
-    StoreOffers                    = 2,
-    OrderVirtualGood               = 3,
-    Json                           = 4,
-    TournamentBundles              = 5,
-    EventRanking                   = 6,
-    EventsModel                    = 7,
-    LeaderboardRanking             = 8,
-    LeaderboardsModel              = 9,
-    EventNotification              = 10,
-    PlayerStats                    = 11,
-    GameNews                       = 12,
-    FileSignedUrls                 = 13,
-    GameInfo                       = 14,
-    PlayerProfiles                 = 15,
-    PlayerlifecycleNotification    = 16,
-    MinigamesList                  = 17,
-    GameNewsVideo                  = 18,
-    PromoCodeRedeem                = 19,
-    StoreGroups                    = 20,
-    AllianceGameState              = 21,
-    AllianceGameChangeNotification = 22,
-    ApmFiltersStatus               = 23,
-    ApmFiltersUpdated              = 24,
-    ListReferralConnections        = 25,
-    RewardRedeem                   = 26,
-    LoginStreakRecalculate         = 27,
-    OrdersVirtualGood              = 28,
-  };
-
-  Type Type_()
-  { return Get<"Type", Type>(); }
-  ByteString* Group()
-  { return Get<"Group", ByteString*>(); }
-};
-
-struct PlatformServiceResponse : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.Platform.Models", "ServiceResponse">;
-
-  il2cpp::List<PlatformEntityGroup*>* EntityGroups()
-  { return Get<"EntityGroups", il2cpp::List<PlatformEntityGroup*>*>(); }
-};
diff --git a/mods/src/prime/ShipActionPanelLocalViewController.h b/mods/src/prime/ShipActionPanelLocalViewController.h
deleted file mode 100644
index df6edc12a..000000000
--- a/mods/src/prime/ShipActionPanelLocalViewController.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-#include "GenericButtonWidget.h"
-
-struct AbilityTimeSpan { int64_t ticks; };
-struct AbilityTimerDataContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "TimerDataContext">;
-  AbilityTimeSpan RemainingTime()
-  { return Get<"RemainingTime", AbilityTimeSpan>(); }
-};
-struct ShipActionPanelLocalViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "ShipActionPanelLocalViewController">;
-  il2cpp::Array<int64_t>* abilityIDs()
-  { return Field<"_abilityIDs", il2cpp::Array<int64_t>*>(); }
-  il2cpp::Array<GenericButtonWidget*>* buttons()
-  { return Field<"_buttons", il2cpp::Array<GenericButtonWidget*>*>(); }
-  AbilityTimerDataContext* GetRemainingCooldown(int64_t abilityId)
-  { return Call<"GetRemainingCooldown", AbilityTimerDataContext*>(abilityId); }
-  bool HasShipAnActiveAbilityWithActiveEffect()
-  { return Call<"HasShipAnActiveAbilityWithActiveEffect", bool>(); }
-};
diff --git a/mods/src/prime/ShipBarItemLocalViewController.h b/mods/src/prime/ShipBarItemLocalViewController.h
deleted file mode 100644
index 5862bec1d..000000000
--- a/mods/src/prime/ShipBarItemLocalViewController.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct ShipBarItemLocalViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "ShipBarItemLocalViewController">;
-};
diff --git a/mods/src/prime/ShipManagementScreenStateViewController.h b/mods/src/prime/ShipManagementScreenStateViewController.h
deleted file mode 100644
index 2719deb61..000000000
--- a/mods/src/prime/ShipManagementScreenStateViewController.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include "Button.h"
-#include "ShipManagementViewContext.h"
-#include "ViewController.h"
-
-struct ShipManagementScreenStateViewController : ViewController<ShipManagementViewContext> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "ShipManagementScreenStateViewController">;
-
-  bool isActiveAndEnabled()
-  { return Get<"isActiveAndEnabled", bool>(); }
-  Button* officerIconButton()
-  { return Field<"_officerIconButton", Button*>(); }
-  Button* swapShipButton()
-  { return Field<"_swapShipButton", Button*>(); }
-};
diff --git a/mods/src/prime/ShipManagementViewContext.h b/mods/src/prime/ShipManagementViewContext.h
deleted file mode 100644
index 3a5e3c180..000000000
--- a/mods/src/prime/ShipManagementViewContext.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-#include "FleetPlayerData.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct ShipManagementViewContext : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "ShipManagementViewContext">;
-
-  FleetPlayerData* CurrentFleet()
-  { return Get<"CurrentFleet", FleetPlayerData*>(); }
-  void Sort()
-  { Call<"Sort">(); }
-  int32_t CurrentIndex()
-  { return Get<"CurrentIndex", int32_t>(); }
-  void SetCurrentIndex(int32_t index)
-  { Set<"CurrentIndex">(index); }
-  void SetLastMovementWasToIncrement(bool increment)
-  { Set<"LastMovementWasToIncrement">(increment); }
-  int32_t ListCount()
-  { return Get<"ListCount", int32_t>(); }
-  il2cpp::List<FleetPlayerData*>* SortedIdleShips()
-  { return Field<"SortedIdleShips", il2cpp::List<FleetPlayerData*>*>(); }
-};
diff --git a/mods/src/prime/ShipManagementViewController.h b/mods/src/prime/ShipManagementViewController.h
deleted file mode 100644
index 148f99dc1..000000000
--- a/mods/src/prime/ShipManagementViewController.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include "ShipManagementViewContext.h"
-#include "ViewController.h"
-
-struct ShipManagementViewController : ViewController<ShipManagementViewContext> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "ShipManagementViewController">;
-
-  // m_context lives on the generic ViewController<T> base; field lookup walks the parents.
-  ShipManagementViewContext* Context()
-  { return Field<"m_context", ShipManagementViewContext*>(); }
-  bool isActiveAndEnabled()
-  { return Get<"isActiveAndEnabled", bool>(); }
-};
diff --git a/mods/src/prime/ShipTileWidget.h b/mods/src/prime/ShipTileWidget.h
deleted file mode 100644
index a9cd16e57..000000000
--- a/mods/src/prime/ShipTileWidget.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-#include "FleetPlayerData.h"
-#include "Widget.h"
-
-struct ShipTileWidget : Widget<FleetPlayerData> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "ShipTileWidget">;
-};
diff --git a/mods/src/prime/ShopSummaryDirector.h b/mods/src/prime/ShopSummaryDirector.h
deleted file mode 100644
index 2765c0388..000000000
--- a/mods/src/prime/ShopSummaryDirector.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct ShopSummaryDirector : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Shop", "ShopSummaryDirector">;
-
-  // SectionID[] declared on SectionDirectorBase; elements are the SectionID enum (Hub.h).
-  il2cpp::Array<int32_t>* backLogicSkipSectionIds()
-  { return Field<"_backLogicSkipSectionIds", il2cpp::Array<int32_t>*>(); }
-};
diff --git a/mods/src/prime/ShortcutsManager.h b/mods/src/prime/ShortcutsManager.h
deleted file mode 100644
index e1f814a2c..000000000
--- a/mods/src/prime/ShortcutsManager.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include "MonoSingleton.h"
-
-struct ShortcutsManager : MonoSingleton<ShortcutsManager> {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.GameInput", "ShortcutsManager">;
-
-  bool ShowKeybindings()
-  { return Get<"ShowKeybindings", bool>(); }
-  void SetShowKeybindings(bool value)
-  { Set<"ShowKeybindings">(value); }
-  // Private static gate the native shortcut actions check (tutorial, modals, text input).
-  static bool CanUseShortcuts()
-  { return Class::Get<"CanUseShortcuts", bool>(); }
-};
diff --git a/mods/src/prime/SpecService.h b/mods/src/prime/SpecService.h
deleted file mode 100644
index 16f75dde7..000000000
--- a/mods/src/prime/SpecService.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include "HullSpec.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct SpecService : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "SpecService">;
-
-  HullSpec* GetHull(int64_t hullId)
-  { return Call<"GetHull", HullSpec*>(hullId); }
-};
diff --git a/mods/src/prime/StarNodeObjectViewerWidget.h b/mods/src/prime/StarNodeObjectViewerWidget.h
deleted file mode 100644
index 7eaf95ca1..000000000
--- a/mods/src/prime/StarNodeObjectViewerWidget.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include "GenericButtonWidget.h"
-#include "ObjectViewerBaseWidget.h"
-
-struct StarNodeObjectViewerWidget : ObjectViewerBaseWidget {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "StarNodeObjectViewerWidget">;
-
-  void OnViewButtonActivation()
-  { Call<"OnViewButtonActivation">(); }
-  void InitiateWarp()
-  { Call<"InitiateWarp">(); }
-  GenericButtonWidget* visitButton()
-  { return Field<"_visitButton", GenericButtonWidget*>(); }
-};
diff --git a/mods/src/prime/StateContainer.h b/mods/src/prime/StateContainer.h
deleted file mode 100644
index a6b3bbac4..000000000
--- a/mods/src/prime/StateContainer.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-// Digit.PrimeServer.Models.StateContainer<T>, a managed struct. Layout matches T values of at most
-// pointer alignment (the game uses it with int enums).
-template <typename T> struct StateContainer {
-  T     currentState;
-  T     previousState;
-  void* equalityComparer;
-
-  T CurrentState() const
-  { return currentState; }
-  T PreviousState() const
-  { return previousState; }
-};
diff --git a/mods/src/prime/SystemViewScaler.h b/mods/src/prime/SystemViewScaler.h
deleted file mode 100644
index 2a82b2b74..000000000
--- a/mods/src/prime/SystemViewScaler.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct SystemViewScaler : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "SystemViewScaler">;
-
-  float baseSystemRadius()
-  { return Field<"_baseSystemRadius", float>(); }
-  void SetBaseSystemRadius(float value)
-  { SetField<"_baseSystemRadius">(value); }
-};
diff --git a/mods/src/prime/TKTouch.h b/mods/src/prime/TKTouch.h
deleted file mode 100644
index 739087db6..000000000
--- a/mods/src/prime/TKTouch.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-enum class TouchPhase : int32_t {
-  Began      = 0,
-  Moved      = 1,
-  Stationary = 2,
-  Ended      = 3,
-  Canceled   = 4,
-};
-
-struct TKTouch : il2cpp::Object {
-  using Class = il2cpp::Class<"TouchKit", "", "TKTouch">;
-
-  TouchPhase phase()
-  { return Field<"phase", TouchPhase>(); }
-  void SetPhase(TouchPhase phase)
-  { SetField<"phase">(phase); }
-};
diff --git a/mods/src/prime/TMP_InputField.h b/mods/src/prime/TMP_InputField.h
deleted file mode 100644
index b92afd234..000000000
--- a/mods/src/prime/TMP_InputField.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct TMP_InputField : il2cpp::Object {
-  using Class = il2cpp::Class<"Unity.TextMeshPro", "TMPro", "TMP_InputField">;
-
-  bool isFocused()
-  { return Get<"isFocused", bool>(); }
-
-  void ActivateInputField()
-  { Call<"ActivateInputField">(); }
-  void DeactivateInputField(bool clearSelection = false)
-  { Call<"DeactivateInputField">(clearSelection); }
-  void SendOnFocusLost()
-  { Call<"SendOnFocusLost">(); }
-  void SendOnFocus()
-  { Call<"SendOnFocus">(); }
-};
diff --git a/mods/src/prime/TabBarViewController.h b/mods/src/prime/TabBarViewController.h
deleted file mode 100644
index b0259c980..000000000
--- a/mods/src/prime/TabBarViewController.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "SelectableList.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct TabBar : SelectableList {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "TabBar">;
-
-  // GenericButtonContext[]
-  il2cpp::Array<il2cpp::Object*>* defaultOptions()
-  { return Field<"_defaultOptions", il2cpp::Array<il2cpp::Object*>*>(); }
-};
-
-struct TabBarViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "TabBarViewController">;
-
-  TabBar* tabBar()
-  { return Field<"_tabBar", TabBar*>(); }
-};
diff --git a/mods/src/prime/TextLocalizer.h b/mods/src/prime/TextLocalizer.h
deleted file mode 100644
index ee225d23b..000000000
--- a/mods/src/prime/TextLocalizer.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-// Digit.Client.UI.TextLocalizer: the label component that renders localized, parameterized text.
-struct TextLocalizer : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "TextLocalizer">;
-
-  // Declared on GraphicLocalizer<,>.
-  Il2CppString* identifier()
-  { return Field<"m_identifier", Il2CppString*>(); }
-  // The backing field, not the SignificantDecimals property.
-  int32_t significantDecimals()
-  { return Field<"m_significantDecimals", int32_t>(); }
-  void SetSignificantDecimals(int32_t value)
-  { SetField<"m_significantDecimals">(value); }
-  bool textOverride()
-  { return Field<"_textOverride", bool>(); }
-  // Declared on GraphicLocalizer<,>: the rendered graphic, resolved lazily even on inactive labels.
-  il2cpp::Object* Target()
-  { return Get<"Target", il2cpp::Object*>(); }
-
-  Il2CppString* CurrentText()
-  { return Call<"CurrentText", Il2CppString*>(); }
-  void ClearTextOverride()
-  { Call<"ClearTextOverride">(); }
-  void OverrideLocalizedText(Il2CppString* text)
-  { Call<"OverrideLocalizedText">(text); }
-};
-
-struct ColourTextLocalizer : TextLocalizer {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "ColourTextLocalizer">;
-};
diff --git a/mods/src/prime/Toast.h b/mods/src/prime/Toast.h
deleted file mode 100644
index 0db5a0bc9..000000000
--- a/mods/src/prime/Toast.h
+++ /dev/null
@@ -1,79 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-enum ToastState {
-  All                       = -1,
-  Standard                  = 0,
-  FactionWarning            = 1,
-  FactionLevelUp            = 2,
-  FactionLevelDown          = 3,
-  FactionDiscovered         = 4,
-  IncomingAttack            = 5,
-  IncomingAttackFaction     = 6,
-  FleetBattle               = 7,
-  StationBattle             = 8,
-  StationVictory            = 9,
-  Victory                   = 10,
-  Defeat                    = 11,
-  StationDefeat             = 12,
-  Tournament                = 14,
-  ArmadaCreated             = 15,
-  ArmadaCanceled            = 16,
-  ArmadaIncomingAttack      = 17,
-  ArmadaBattleWon           = 18,
-  ArmadaBattleLost          = 19,
-  DiplomacyUpdated          = 20,
-  JoinedTakeover            = 21,
-  CompetitorJoinedTakeover  = 22,
-  AbandonedTerritory        = 23,
-  TakeoverVictory           = 24,
-  TakeoverDefeat            = 25,
-  TreasuryProgress          = 26,
-  TreasuryFull              = 27,
-  Achievement               = 28,
-  AssaultVictory            = 29,
-  AssaultDefeat             = 30,
-  ChallengeComplete         = 31,
-  ChallengeFailed           = 32,
-  StrikeHit                 = 33,
-  StrikeDefeat              = 34,
-  WarchestProgress          = 35,
-  WarchestFull              = 36,
-  PartialVictory            = 37,
-  ArenaTimeLeft             = 38,
-  ChainedEventScored        = 39,
-  FleetPresetApplied        = 40,
-  SurgeWarmUpEnded              = 41,
-  SurgeHostileGroupDefeated     = 42,
-  SurgeTimeLeft                 = 43,
-  QueueForLeaseActivated        = 44,
-  QueueForLeaseExpired          = 45,
-  PermanentQueuePurchased       = 46,
-  OutpostStartedOrEnded         = 47,
-  CrossAllianceArmadaVictory    = 48,
-  CrossAllianceArmadaDefeat     = 49,
-  CrossAllianceArmadaPartialVictory = 50,
-  FactionWeeklyEventsProgress   = 51,
-  FactionWeeklyEventsComplete   = 52,
-  ArmadaPlayerBlocked           = 53,
-  ArmadaPlayerUnblocked         = 54,
-  DynamicCrisisUpdate           = 55,
-  DynamicCrisisFailed           = 56,
-  DynamicCrisisCompleted        = 57,
-  GalacticAnomalySystemEntered  = 58,
-};
-
-struct Toast : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "Toast">;
-
-  il2cpp::Array<Il2CppObject*>* get_TextParameters()
-  { return Get<"TextParameters", il2cpp::Array<Il2CppObject*>*>(); }
-  // LocaleTextContext
-  void* get_TextLocaleTextContext()
-  { return Get<"TextLocaleTextContext", void*>(); }
-  Il2CppObject* get_Data()
-  { return Get<"Data", Il2CppObject*>(); }
-  int get_State()
-  { return Get<"State", ToastState>(); }
-};
diff --git a/mods/src/prime/Transform.h b/mods/src/prime/Transform.h
deleted file mode 100644
index 496db99a7..000000000
--- a/mods/src/prime/Transform.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include "GameObject.h"
-#include "Vector3.h"
-
-#include <il2cpp/il2cpp.h>
-
-struct Transform : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Transform">;
-
-  int32_t childCount()
-  { return Get<"childCount", int32_t>(); }
-  Transform* GetChild(int32_t index)
-  { return Call<"GetChild", Transform*>(index); }
-  Transform* parent()
-  { return Get<"parent", Transform*>(); }
-  GameObject* gameObject()
-  { return Get<"gameObject", GameObject*>(); }
-  Vector3 localScale()
-  { return Get<"localScale", Vector3>(); }
-  void SetLocalScale(Vector3 value)
-  { Set<"localScale">(value); }
-  void SetLocalEulerAngles(Vector3 value)
-  { Set<"localEulerAngles">(value); }
-  void SetParent(Transform* parent, bool worldPositionStays)
-  { Call<"SetParent">(parent, worldPositionStays); }
-  void SetAsFirstSibling()
-  { Call<"SetAsFirstSibling">(); }
-  // Finds a descendant by slash-separated path, e.g. "Hint/Background".
-  Transform* Find(Il2CppString* path)
-  { return Call<"Find", Transform*>(path); }
-};
diff --git a/mods/src/prime/TransitionManager.h b/mods/src/prime/TransitionManager.h
deleted file mode 100644
index 73210d33a..000000000
--- a/mods/src/prime/TransitionManager.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "BlurController.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct TransitionManager : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.LoadingScreen", "TransitionManager">;
-
-  // Public field named BlurController; the S prefix keeps the type name visible in this scope.
-  BlurController* SBlurController()
-  { return Field<"BlurController", BlurController*>(); }
-  int32_t waitFrames()
-  { return Field<"_waitFrames", int32_t>(); }
-  void SetWaitFrames(int32_t value)
-  { SetField<"_waitFrames">(value); }
-};
diff --git a/mods/src/prime/TransitionViewController.h b/mods/src/prime/TransitionViewController.h
deleted file mode 100644
index c23b3a838..000000000
--- a/mods/src/prime/TransitionViewController.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct TransitionViewController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.LoadingScreen", "TransitionViewController">;
-
-  // Image
-  void* staticOverride()
-  { return Field<"_staticOverride", void*>(); }
-  // Animator
-  void* animator()
-  { return Field<"_animator", void*>(); }
-  // SmartScroller
-  void* scroller()
-  { return Field<"_scroller", void*>(); }
-};
diff --git a/mods/src/prime/UIBehaviour.h b/mods/src/prime/UIBehaviour.h
deleted file mode 100644
index 07edd67a3..000000000
--- a/mods/src/prime/UIBehaviour.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct UIBehaviour : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.UI", "UnityEngine.EventSystems", "UIBehaviour">;
-};
diff --git a/mods/src/prime/UnityWebRequest.h b/mods/src/prime/UnityWebRequest.h
deleted file mode 100644
index 5f636a94f..000000000
--- a/mods/src/prime/UnityWebRequest.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct UnityWebRequest : il2cpp::Object {
-  using Class = il2cpp::Class<"UnityEngine.UnityWebRequestModule", "UnityEngine.Networking", "UnityWebRequest">;
-
-  uintptr_t get_uploadHandler()
-  { return reinterpret_cast<uintptr_t>(Get<"uploadHandler", Il2CppObject*>()); }
-};
diff --git a/mods/src/prime/UserProfile.h b/mods/src/prime/UserProfile.h
deleted file mode 100644
index 62da80e24..000000000
--- a/mods/src/prime/UserProfile.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-struct UserProfile : il2cpp::Object {
-  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "UserProfile">;
-
-  int64_t LocaId()
-  { return Field<"_locaId", int64_t>(); }
-  Il2CppString* Name()
-  { return Field<"name_", Il2CppString*>(); }
-  Il2CppString* UserId()
-  { return Get<"UserId", Il2CppString*>(); }
-  int32_t Level()
-  { return Get<"Level", int32_t>(); }
-};
diff --git a/mods/src/prime/UserProfileManager.h b/mods/src/prime/UserProfileManager.h
index e032c778d..a27b45e14 100644
--- a/mods/src/prime/UserProfileManager.h
+++ b/mods/src/prime/UserProfileManager.h
@@ -1,11 +1,13 @@
 #pragma once
 
-#include "MonoSingleton.h"
-#include "UserProfile.h"
+#include "prime/server.h"
 
-struct UserProfileManager : MonoSingleton<UserProfileManager> {
+struct UserProfileManager : il2cpp::Object {
   using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.PlayerProfile", "UserProfileManager">;
 
+  static UserProfileManager* Instance()
+  { return Class::Get<"Instance", UserProfileManager*>(); }
+
   [[nodiscard]] UserProfile* GetLocalUserProfile()
   { return Call<"GetLocalUserProfile", UserProfile*>(); }
 };
diff --git a/mods/src/prime/UserProfileWidget.h b/mods/src/prime/UserProfileWidget.h
deleted file mode 100644
index 205f08845..000000000
--- a/mods/src/prime/UserProfileWidget.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-#include <il2cpp/il2cpp.h>
-struct PlayerTitleWidget : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.PlayerAvatars", "PlayerTitleWidget">;
-};
-struct UserProfileWidget : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.PlayerProfile", "UserProfileWidget">;
-  PlayerTitleWidget* playerTitleWidget()
-  { return Field<"_playerTitleWidget", PlayerTitleWidget*>(); }
-};
diff --git a/mods/src/prime/Vector2.h b/mods/src/prime/Vector2.h
deleted file mode 100644
index 329435ede..000000000
--- a/mods/src/prime/Vector2.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <compare>
-
-struct Vector2 {
-  float x, y;
-};
-
-#pragma pack(push, 1)
-struct vec2 {
-  float x, y;
-
-  friend auto operator<=>(const vec2&, const vec2&) = default;
-};
-#pragma pack(pop)
\ No newline at end of file
diff --git a/mods/src/prime/Vector3.h b/mods/src/prime/Vector3.h
deleted file mode 100644
index 2f1b0cf32..000000000
--- a/mods/src/prime/Vector3.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-struct Vector3 {
-  using Class = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Vector3">;
-
-  float x;
-  float y;
-  float z;
-
-  static Vector3 zero()
-  { return Class::Field<"zeroVector", Vector3>(); }
-};
diff --git a/mods/src/prime/ViewController.h b/mods/src/prime/ViewController.h
deleted file mode 100644
index 5ec1584ab..000000000
--- a/mods/src/prime/ViewController.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-// Digit.Client.UI.ViewController`1. Members resolve on each controller's runtime class.
-template <typename T> struct ViewController : il2cpp::Object {
-  T* CanvasContext()
-  { return Get<"CanvasContext", T*>(); }
-};
diff --git a/mods/src/prime/VisibilityController.h b/mods/src/prime/VisibilityController.h
deleted file mode 100644
index 87713329c..000000000
--- a/mods/src/prime/VisibilityController.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-#include <cstdint>
-
-enum class VisibilityState : int32_t // TypeDefIndex: 13743
-{
-  Unknown = 0,
-  Show    = 1,
-  Hide    = 2,
-  Hidden  = 3,
-  Visible = 4
-};
-
-struct VisibilityController : il2cpp::Object {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "VisibilityController">;
-
-  // bool selects Show(bool)/Hide(bool) over the int entry-point overloads.
-  void Show(bool instant = false)
-  { Call<"Show">(instant); }
-  void Hide(bool instant = false)
-  { Call<"Hide">(instant); }
-
-  VisibilityState state()
-  { return Field<"_state", VisibilityState>(); }
-  VisibilityState State()
-  { return Get<"VisibilityState", VisibilityState>(); }
-};
diff --git a/mods/src/prime/WaveDefenseObjectViewerWidget.h b/mods/src/prime/WaveDefenseObjectViewerWidget.h
deleted file mode 100644
index ac8ada8bd..000000000
--- a/mods/src/prime/WaveDefenseObjectViewerWidget.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include "GenericButtonWidget.h"
-#include "ObjectViewerBaseWidget.h"
-
-struct WaveDefenseObjectViewerWidget : ObjectViewerBaseWidget {
-  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "WaveDefenseObjectViewerWidget">;
-
-  // Every active viewer of this class in the loaded scenes.
-  static il2cpp::Array<WaveDefenseObjectViewerWidget*>* FindActiveViewers()
-  {
-    using UnityObject = il2cpp::Class<"UnityEngine.CoreModule", "UnityEngine", "Object">;
-    auto* type        = Class::TypeObject();
-    return type ? UnityObject::Call<"FindObjectsOfType", il2cpp::Array<WaveDefenseObjectViewerWidget*>*>(type)
-                : nullptr;
-  }
-
-  GenericButtonWidget* primaryButton()
-  { return Field<"_primaryButton", GenericButtonWidget*>(); }
-
-  void PressPrimaryButton()
-  {
-    auto* widget = primaryButton();
-    if (!widget || !widget->isActiveAndEnabled()) {
-      return;
-    }
-    auto* context  = widget->Context();
-    auto* listener = widget->SemaphoreListener();
-    if (context && context->Interactable() && listener) {
-      if (auto* button = listener->TheButton()) {
-        button->Press();
-      }
-    }
-  }
-};
diff --git a/mods/src/prime/Widget.h b/mods/src/prime/Widget.h
deleted file mode 100644
index 24768ea59..000000000
--- a/mods/src/prime/Widget.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include <il2cpp/il2cpp.h>
-
-// Digit.Client.UI.Widget`1. Members resolve on each widget's runtime class.
-template <typename T> struct Widget : il2cpp::Object {
-  T* Context()
-  { return Get<"Context", T*>(); }
-  bool enabled()
-  { return Get<"enabled", bool>(); }
-  bool isActiveAndEnabled()
-  { return Get<"isActiveAndEnabled", bool>(); }
-  bool IsActive()
-  { return Call<"IsActive", bool>(); }
-};
diff --git a/mods/src/prime/ZoomLevels.h b/mods/src/prime/ZoomLevels.h
deleted file mode 100644
index d5b0f1295..000000000
--- a/mods/src/prime/ZoomLevels.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-enum class ZoomLevels {
-  None   = 0,
-  Near   = 1,
-  Middle = 2,
-  Far    = 3,
-};
diff --git a/mods/src/prime/chat.h b/mods/src/prime/chat.h
new file mode 100644
index 000000000..c1b3d58eb
--- /dev/null
+++ b/mods/src/prime/chat.h
@@ -0,0 +1,101 @@
+#pragma once
+
+// Chat manager and chat view controllers.
+
+#include "prime/ui.h"
+
+#include <il2cpp/il2cpp.h>
+
+enum class ChatChannelCategory : int32_t {
+  None            = -1,
+  Newbie          = 0,
+  Global          = 1,
+  Alliance        = 2,
+  Private         = 3,
+  Private_Message = 4,
+  Block           = 5,
+  Regional        = 6,
+};
+
+enum class ChatViewMode : int32_t {
+  Fullscreen = 0,
+  Side       = 1,
+};
+
+struct ChatManager : MonoSingleton<ChatManager> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Chat", "ChatManager">;
+
+  void OpenChannel(ChatChannelCategory category = ChatChannelCategory::Alliance)
+  { Call<"OpenChannel">(category, il2cpp::NewString("")); }
+
+  void OpenChannel(ChatChannelCategory category, ChatViewMode viewMode)
+  {
+    SetViewMode(viewMode);
+    OpenChannel(category);
+  }
+
+  bool CanSeeNewbieChat()
+  { return Call<"CanSeeNewbieChat", bool>(); }
+  bool CanSeeRegionalChat()
+  { return Call<"CanSeeRegionalChat", bool>(); }
+
+  bool IsSideChatOpen()
+  { return Get<"IsSideChatOpen", bool>(); }
+  bool IsSideChatAllowed()
+  { return Get<"IsSideChatAllowed", bool>(); }
+  bool isContextInitialised()
+  { return Field<"_isContextInitialised", bool>(); }
+  void SetViewMode(ChatViewMode value)
+  { Set<"ViewMode">(value); }
+};
+
+struct SwipeScroller : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "SwipeScroller">;
+
+  int32_t currentContentIndex()
+  { return Field<"_currentContentIndex", int32_t>(); }
+  void FocusOnInstantly(int32_t index)
+  { Call<"FocusOnInstantly">(index); }
+};
+
+struct ChatPreviewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Chat", "ChatPreviewController">;
+
+  SwipeScroller* swipeScroller()
+  { return Field<"_swipeScroller", SwipeScroller*>(); }
+  void SetFocusedPanel(ChatChannelCategory value)
+  { SetField<"_focusedPanel">(value); }
+  // Set by the game after its visibility refresh for a section change.
+  bool isSectionChangedCompleted()
+  { return Field<"_isSectionChangedCompleted", bool>(); }
+};
+
+struct ChatMessageListLocalViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Chat", "ChatMessageListLocalViewController">;
+
+  unity::TMP_InputField* inputField()
+  { return Field<"_inputField", unity::TMP_InputField*>(); }
+};
+
+struct FullScreenChatViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Chat", "FullScreenChatViewController">;
+
+  ChatMessageListLocalViewController* messageList()
+  { return Field<"_messageList", ChatMessageListLocalViewController*>(); }
+  TabBarViewController* categoriesTabBarViewController()
+  { return Field<"_categoriesTabBarViewController", TabBarViewController*>(); }
+};
+
+struct PlayerTitleWidget : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.PlayerAvatars", "PlayerTitleWidget">;
+};
+struct UserProfileWidget : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.PlayerProfile", "UserProfileWidget">;
+  PlayerTitleWidget* playerTitleWidget()
+  { return Field<"_playerTitleWidget", PlayerTitleWidget*>(); }
+};
+struct ChatMessageWidget : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Chat", "ChatMessageWidget">;
+  UserProfileWidget* userProfileWidget()
+  { return Field<"_userProfileWidget", UserProfileWidget*>(); }
+};
diff --git a/mods/src/prime/fleet.h b/mods/src/prime/fleet.h
new file mode 100644
index 000000000..7c8ef6aeb
--- /dev/null
+++ b/mods/src/prime/fleet.h
@@ -0,0 +1,530 @@
+#pragma once
+
+// Player fleets and ships: fleet data and managers, the fleet bar, the action queue, and the ship management screens
+// and dock.
+
+#include "prime/Hub.h"
+#include "prime/server.h"
+#include "prime/ui.h"
+
+#include <il2cpp/il2cpp.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+enum class DeployedFleetType : int32_t {
+  Nonexistent,
+  Player,
+  Marauder,
+  NpcInstantiated,
+  Sentinel,
+  Alliance,
+  Challenge,
+};
+
+struct FleetDeployedData : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetDeployedData">;
+
+  HullSpec* Hull()
+  { return Get<"Hull", HullSpec*>(); }
+  // Nonexistent when the property is missing.
+  DeployedFleetType FleetType()
+  { return Get<"FleetType", DeployedFleetType>(); }
+};
+
+struct BattleTargetData : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "BattleTargetData">;
+
+  FleetDeployedData* TargetFleetDeployedData()
+  { return Field<"TargetFleetDeployedData", FleetDeployedData*>(); }
+};
+
+enum class FleetState : int32_t {
+  Unknown                = 0,
+  IdleInSpace            = 1,
+  Docked                 = 2,
+  Mining                 = 4,
+  Destroyed              = 8,
+  TieringUp              = 16,
+  CanReplaceOfficers     = 18,
+  Repairing              = 32,
+  CannotLaunch           = 56,
+  Battling               = 64,
+  WarpCharging           = 128,
+  Warping                = 256,
+  CanRemove              = 384,
+  Impulsing              = 512,
+  CanActivateAbility     = 513,
+  CanDisco               = 515,
+  Capturing              = 1024,
+  AutoHunting            = 2048,
+  CannotMove             = 2552,
+  CanManage              = 2947,
+  CanBeTargetedByAbility = 3589,
+  CanEngage              = 3591,
+  Outposting             = 4096,
+  CanRecall              = 5637,
+  Deployed               = 8133,
+  CanLocate              = 8135
+};
+
+// Cargo, mining slot and timers off FleetPlayerData, read for fleet sync. The interfaces are bound as such: their
+// getters dispatch to the runtime class, which also covers FleetMiningSlot's explicit IMiningSlot implementation.
+
+// System.DateTime: ticks in the low 62 bits, the Kind in the top two.
+struct DateTime {
+  uint64_t dateData;
+
+  // Unix seconds, or empty for DateTime.MinValue (unset).
+  std::optional<int64_t> UnixSeconds() const
+  {
+    const auto ticks = static_cast<int64_t>(dateData & 0x3FFFFFFFFFFFFFFFull);
+    if (ticks <= 0)
+      return std::nullopt;
+    return (ticks - 621355968000000000LL) / 10000000LL;
+  }
+};
+
+// Concrete: ProgressData, CargoProgressData.
+struct IProgressData : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "IProgressData">;
+
+  double CurrentValue()
+  { return Get<"CurrentValue", double>(); }
+  double MaxValue()
+  { return Get<"MaxValue", double>(); }
+};
+
+struct CargoHoldData : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "CargoHoldData">;
+
+  IProgressData* CurrentCargo()
+  { return Get<"CurrentCargo", IProgressData*>(); }
+  IProgressData* ProtectedCargoProgress()
+  { return Get<"ProtectedCargoProgress", IProgressData*>(); }
+};
+
+struct IMiningNodeParams : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "IMiningNodeParams">;
+
+  int64_t Amount()
+  { return Get<"Amount", int64_t>(); }
+};
+
+// Concrete: FleetMiningSlot, MiningSlot.
+struct IMiningSlot : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "IMiningSlot">;
+
+  int64_t ParentId()
+  { return Get<"ParentId", int64_t>(); }
+  int64_t ResourceId()
+  { return Get<"ResourceId", int64_t>(); }
+  double AmountMined()
+  { return Get<"AmountMined", double>(); }
+  DateTime OccupyTimeUtc()
+  { return Get<"OccupyTimeUtc", DateTime>(); }
+  IMiningNodeParams* PointData()
+  { return Get<"PointData", IMiningNodeParams*>(); }
+};
+
+// Concrete: MiningSlotTimer and others.
+struct ITimerData : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "ITimerData">;
+
+  DateTime DueTime()
+  { return Get<"DueTime", DateTime>(); }
+};
+
+// A ship name as the game shows it, in the player's language, for a hull's localisation id; empty for none.
+inline std::string LocalizedShipName(int64_t loca_id)
+{
+  if (loca_id <= 0)
+    return {};
+  auto* context = il2cpp::New<LocaleTextContext>(il2cpp::NewString("ship_name_" + std::to_string(loca_id)),
+                                                 il2cpp::NewString("ships"));
+  auto* name    = context ? Localizer::Localise(context) : nullptr;
+  return name ? il2cpp::ToUtf8(name) : std::string();
+}
+
+struct FleetPlayerData : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetPlayerData">;
+
+  int32_t Index()
+  { return Get<"Index", int32_t>(); }
+  HullSpec* Hull()
+  { return Get<"Hull", HullSpec*>(); }
+  FleetState CurrentState()
+  { return Get<"CurrentState", FleetState>(); }
+  FleetState PreviousState()
+  { return Get<"PreviousState", FleetState>(); }
+  uint64_t Id()
+  { return Get<"Id", uint64_t>(); }
+  int64_t Level()
+  { return Get<"Level", int64_t>(); }
+  bool HasShip()
+  { return Get<"HasShip", bool>(); }
+  int64_t HullId()
+  { return Get<"HullId", int64_t>(); }
+  bool HasAppliedTech()
+  {
+    struct BaseShip : il2cpp::Object {
+      using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "BaseShip">;
+      int64_t Id()
+      { return Get<"Id", int64_t>(); }
+    };
+    struct Slot : il2cpp::Object {
+      using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "EntitySlot">;
+      int64_t SpecId()
+      { return Get<"SlotSpecId", int64_t>(); }
+      bool HasItem()
+      {
+        static const auto* getter = Class::Method("get_SlotItemId", 0).Info();
+        if (!getter || (getter->flags & METHOD_ATTRIBUTE_STATIC)
+            || getter->return_type->type != IL2CPP_TYPE_GENERICINST)
+          return false;
+        // Runtime invocation boxes Nullable<Int64> as null or its value, without assuming its native layout.
+        return il2cpp::detail::InvokeBoxed(getter, this, nullptr) != nullptr;
+      }
+    };
+    struct Manager : il2cpp::Object {
+      using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ForbiddenTechs", "ForbiddenTechManager">;
+      bool ActiveSlots(int64_t ship_id, il2cpp::List<Slot*>*& slots)
+      { return Call<"TryGetActiveForbiddenTechSlot", bool>(ship_id, std::ref(slots)); }
+    };
+    auto*                ship    = Get<"Ship", BaseShip*>();
+    auto*                manager = Manager::Class::Get<"Instance", Manager*>();
+    il2cpp::List<Slot*>* slots   = nullptr;
+    if (!ship || !manager || !manager->ActiveSlots(ship->Id(), slots) || !slots)
+      return false;
+    for (auto* slot : *slots) {
+      if (!slot)
+        continue;
+      const auto spec = slot->SpecId();
+      if ((spec == 3502081615 || spec == 953301906) && slot->HasItem())
+        return true;
+    }
+    return false;
+  }
+
+  // Live state, read for fleet sync.
+  bool IsHome()
+  { return Get<"IsHome", bool>(); }
+  bool IsDeployed()
+  { return Get<"IsDeployed", bool>(); }
+  bool IsMining()
+  { return Get<"IsMining", bool>(); }
+  bool IsRepairing()
+  { return Get<"IsRepairing", bool>(); }
+  bool IsDamaged()
+  { return Get<"IsDamaged", bool>(); }
+  bool IsDestroyed()
+  { return Get<"IsDestroyed", bool>(); }
+  int32_t DrydockID()
+  { return Get<"DrydockID", int32_t>(); }
+  float CargoResourceFillLevel()
+  { return Get<"CargoResourceFillLevel", float>(); }
+  CargoHoldData* CargoHold()
+  { return Get<"CargoHoldData", CargoHoldData*>(); }
+  IMiningSlot* MiningData()
+  { return Get<"MiningData", IMiningSlot*>(); }
+  ITimerData* Timer()
+  { return Get<"Timer", ITimerData*>(); }
+  // No property for the mining timer, so read the private field.
+  ITimerData* MiningSlotTimer()
+  { return Field<"_miningSlotTimer", ITimerData*>(); }
+  float GetMiningRate()
+  { return Call<"GetMiningRate", float>(); }
+  // Damage on the fleet's ship, so a docked ship's hull is known without the server. Empty without a ship.
+  std::optional<float> HullDamage()
+  {
+    auto* ship = Get<"Ship", ShipModel*>();
+    return ship ? std::optional(ship->HullDamage()) : std::nullopt;
+  }
+
+  int64_t GetLocaId()
+  { return Call<"GetLocaId", int64_t>(); }
+
+  // The ship's name as the game shows it, in the player's language; empty without a hull.
+  std::string DisplayName()
+  { return LocalizedShipName(Hull() ? GetLocaId() : 0); }
+};
+
+using IActionData = void*;
+
+// Digit.PrimeServer.Models.ActionType is a struct around a flag value, not an enum, so it crosses the
+// managed boundary as a 4-byte struct.
+struct ActionType {
+  int32_t flagValue;
+
+  friend bool operator==(ActionType, ActionType) = default;
+
+  static const ActionType Manage;
+  static const ActionType Repair;
+  static const ActionType Recall;
+};
+
+inline constexpr ActionType ActionType::Manage{-1997567611};
+inline constexpr ActionType ActionType::Repair{-1850668115};
+inline constexpr ActionType ActionType::Recall{-1851055311};
+
+enum class ActionBehaviour : int32_t {
+  Default             = 1,
+  Instant             = 2,
+  Speedup             = 4,
+  Collect             = 8,
+  AskHelp             = 16,
+  RequestConfirmation = 32,
+};
+
+struct AbilityTimeSpan {
+  int64_t ticks;
+};
+
+struct AbilityTimerDataContext : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "TimerDataContext">;
+  AbilityTimeSpan RemainingTime()
+  { return Get<"RemainingTime", AbilityTimeSpan>(); }
+};
+
+struct ShipActionPanelLocalViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "ShipActionPanelLocalViewController">;
+  il2cpp::Array<int64_t>* abilityIDs()
+  { return Field<"_abilityIDs", il2cpp::Array<int64_t>*>(); }
+  il2cpp::Array<GenericButtonWidget*>* buttons()
+  { return Field<"_buttons", il2cpp::Array<GenericButtonWidget*>*>(); }
+  AbilityTimerDataContext* GetRemainingCooldown(int64_t abilityId)
+  { return Call<"GetRemainingCooldown", AbilityTimerDataContext*>(abilityId); }
+  bool HasShipAnActiveAbilityWithActiveEffect()
+  { return Call<"HasShipAnActiveAbilityWithActiveEffect", bool>(); }
+};
+
+struct FleetLocalViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "FleetLocalViewController">;
+
+  ShipActionPanelLocalViewController* shipActionPanelLocalViewController()
+  { return Field<"_shipActionPanelLocalViewController", ShipActionPanelLocalViewController*>(); }
+  FleetPlayerData* fleet()
+  { return Get<"fleet", FleetPlayerData*>(); }
+
+  void CancelButtonClicked()
+  { Call<"CancelButtonClicked">(); }
+
+  // callback is an Action<bool, ActionBehaviour>; null is accepted.
+  bool RequestAction(IActionData target, ActionType type, int64_t index, ActionBehaviour behaviourMask,
+                     void* callback = nullptr)
+  { return Call<"RequestAction", bool>(target, type, index, behaviourMask, callback); }
+};
+
+struct FleetBarContext : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "FleetBarContext">;
+  il2cpp::Array<FleetPlayerData*>* FleetData()
+  { return Get<"FleetData", il2cpp::Array<FleetPlayerData*>*>(); }
+};
+
+struct FleetBarViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "FleetBarViewController">;
+
+  FleetBarContext* CanvasContext()
+  { return Get<"CanvasContext", FleetBarContext*>(); }
+
+  // The int overload; the other takes the list element Component.
+  void RequestSelect(int32_t index, bool simulated = false)
+  { Call<"RequestSelect">(index, simulated); }
+  bool IsIndexSelected(int32_t index)
+  { return Call<"IsIndexSelected", bool>(index); }
+
+  FleetLocalViewController* fleetPanelController()
+  { return Field<"_fleetPanelController", FleetLocalViewController*>(); }
+
+  // The fleet whose panel is open in the bar, or null.
+  FleetPlayerData* SelectedFleet()
+  {
+    auto* panel = fleetPanelController();
+    return panel ? panel->fleet() : nullptr;
+  }
+};
+
+struct FleetsManager : MonoSingleton<FleetsManager> {
+  bool HasFleetService()
+  {
+    static FieldInfo* const field =
+        Class::Raw() ? il2cpp_class_get_field_from_name(Class::Raw(), "_fleetServiceCache") : nullptr;
+    static const MethodInfo* const has_service =
+        field ? il2cpp_class_get_method_from_name(il2cpp_class_from_type(il2cpp_field_get_type(field)),
+                                                  "get_HasService", 0)
+              : nullptr;
+    if (!has_service) {
+      return false;
+    }
+
+    auto* cache = reinterpret_cast<char*>(this) + il2cpp_field_get_offset(field);
+    if (*reinterpret_cast<void**>(cache)) {
+      return true;
+    }
+
+    Il2CppException* exception = nullptr;
+    auto*            result    = il2cpp_runtime_invoke(has_service, cache, nullptr, &exception);
+    return !exception && result && *static_cast<bool*>(il2cpp_object_unbox(result));
+  }
+  FleetPlayerData* GetFleetPlayerData(int32_t index)
+  { return Call<"GetFleetPlayerData", FleetPlayerData*>(index); }
+
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.FleetManagement", "FleetsManager">;
+
+  void RequestViewFleet(FleetPlayerData* fleetData, bool showSystemInfo = false)
+  { Call<"RequestViewFleet">(fleetData, showSystemInfo); }
+
+  FleetPlayerData* GetSelectedFleetData()
+  { return Call<"GetSelectedFleetData", FleetPlayerData*>(); }
+};
+
+struct ForbiddenTechManager : MonoSingleton<ForbiddenTechManager> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ForbiddenTechs", "ForbiddenTechManager">;
+
+  bool TryGetEntitySlotFromForbiddenTech(int64_t tech_id, EntitySlot*& slot)
+  { return Call<"TryGetEntitySlotFromForbiddenTech", bool>(tech_id, std::ref(slot)); }
+
+  // _fleetServiceCache is a CachedService<FleetService> struct whose Service getter resolves the service lazily. The
+  // getter runs on a copy, so the manager's own cache is left as it was; the runtime takes the struct receiver
+  // unboxed.
+  FleetService* fleetService()
+  {
+    struct CachedService {
+      FleetService* service;
+    };
+    auto cache = Field<"_fleetServiceCache", CachedService>();
+    if (cache.service)
+      return cache.service;
+    static FieldInfo* const field =
+        Class::Raw() ? il2cpp_class_get_field_from_name(Class::Raw(), "_fleetServiceCache") : nullptr;
+    static const MethodInfo* const getter =
+        field ? il2cpp_class_get_method_from_name(il2cpp_class_from_type(il2cpp_field_get_type(field)), "get_Service",
+                                                  0)
+              : nullptr;
+    if (!getter)
+      return nullptr;
+    return reinterpret_cast<FleetService*>(il2cpp::detail::InvokeBoxed(getter, &cache, nullptr));
+  }
+};
+
+struct DeploymentManager : MonoSingleton<DeploymentManager> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "", "DeploymentManager">;
+
+  bool HasInstantWarpAbility(FleetPlayerData* selectedFleet)
+  { return Call<"HasInstantWarpAbility", bool>(selectedFleet); }
+};
+
+struct ActionQueueManager : MonoSingleton<ActionQueueManager> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Prime.ActionQueue", "ActionQueueManager">;
+
+  void ClearQueue(FleetPlayerData* playerData)
+  { Call<"ClearQueue">(playerData); }
+  bool IsQueueFull(FleetPlayerData* playerData)
+  { return Call<"IsQueueFull", bool>(playerData); }
+  bool IsQueueUnlocked()
+  { return Call<"IsQueueUnlocked", bool>(); }
+};
+
+struct FleetMeshSelector : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "FleetMeshSelector">;
+
+  unity::GameObject* LoadedObject()
+  { return Get<"LoadedObject", unity::GameObject*>(); }
+};
+
+struct CourseData : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "CourseData">;
+
+  FleetPlayerData* PlayerFleet()
+  { return Get<"PlayerFleet", FleetPlayerData*>(); }
+};
+
+// Places a ship model in system view; the hook scales it by ui_scale_ship.
+using SystemViewShip = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "SystemViewShip">;
+
+struct ShipManagementViewContext : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "ShipManagementViewContext">;
+
+  FleetPlayerData* CurrentFleet()
+  { return Get<"CurrentFleet", FleetPlayerData*>(); }
+  void Sort()
+  { Call<"Sort">(); }
+  int32_t CurrentIndex()
+  { return Get<"CurrentIndex", int32_t>(); }
+  void SetCurrentIndex(int32_t index)
+  { Set<"CurrentIndex">(index); }
+  void SetLastMovementWasToIncrement(bool increment)
+  { Set<"LastMovementWasToIncrement">(increment); }
+  int32_t ListCount()
+  { return Get<"ListCount", int32_t>(); }
+  il2cpp::List<FleetPlayerData*>* SortedIdleShips()
+  { return Field<"SortedIdleShips", il2cpp::List<FleetPlayerData*>*>(); }
+};
+
+struct ShipManagementViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "ShipManagementViewController">;
+
+  // m_context lives on the generic ViewController`1 base; field lookup walks the parents.
+  ShipManagementViewContext* Context()
+  { return Field<"m_context", ShipManagementViewContext*>(); }
+  bool isActiveAndEnabled()
+  { return Get<"isActiveAndEnabled", bool>(); }
+};
+
+struct ShipManagementScreenStateViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "ShipManagementScreenStateViewController">;
+
+  bool isActiveAndEnabled()
+  { return Get<"isActiveAndEnabled", bool>(); }
+  unity::Button* officerIconButton()
+  { return Field<"_officerIconButton", unity::Button*>(); }
+  unity::Button* swapShipButton()
+  { return Field<"_swapShipButton", unity::Button*>(); }
+};
+
+struct AssignShipsWidget : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "AssignShipsWidget">;
+
+  InputFieldWidget* inputField()
+  { return Field<"_inputField", InputFieldWidget*>(); }
+  bool isActiveAndEnabled()
+  { return Get<"isActiveAndEnabled", bool>(); }
+  ButtonAndContextWrapper* assignButton()
+  { return Field<"_assignButton", ButtonAndContextWrapper*>(); }
+  SelectableList* selectableList()
+  { return Field<"_selectableList", SelectableList*>(); }
+};
+
+struct ShipTileWidget : Widget<FleetPlayerData> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Ships", "ShipTileWidget">;
+};
+
+// Older clients lack this class; there the binding logs it once and ViewOwnHaven does nothing.
+struct PlanetaryBaseManager : MonoSingleton<PlanetaryBaseManager> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.PlanetaryBase", "PlanetaryBaseManager">;
+
+  static void ViewOwnHaven()
+  {
+    auto* manager  = Instance();
+    auto* sections = Hub::Sections();
+    if (!manager || !sections)
+      return;
+
+    // Preserve the game's Iconian Gateway prerequisite and its locked-building message.
+    if (!manager->Call<"IsPlanetaryBaseCenterReady", bool>(true))
+      return;
+    // PlanetarySectionContext is reserved for visiting another player's Haven. Passing no context makes the
+    // PlanetarySectionDirector initialize the complete local Haven state from the service cache.
+    sections->TriggerSectionChange(SectionID::Starbase_Planetary, nullptr, false, false, true);
+  }
+};
+
+struct ActivatedAbilityManager : MonoSingleton<ActivatedAbilityManager> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ActivatedAbilities", "ActivatedAbilityManager">;
+  static constexpr int32_t RevealHostileVgerAbilityType = 86002;
+  int32_t                  GetActivatedAbilityType(int64_t abilityId)
+  { return Call<"GetActivatedAbilityType", int32_t>(abilityId); }
+  bool CanUseAbility(FleetPlayerData* fleet, int64_t abilityId)
+  { return Call<"CanUseAbility", bool>(fleet, abilityId); }
+};
diff --git a/mods/src/prime/hud.h b/mods/src/prime/hud.h
new file mode 100644
index 000000000..0f7f78cc8
--- /dev/null
+++ b/mods/src/prime/hud.h
@@ -0,0 +1,93 @@
+#pragma once
+
+// The HUD around the space views: the mission buttons, the faction and system panel, the alliance drawer, and the
+// galactic anomaly the viewed system may have.
+
+#include "prime/ui.h"
+
+#include <il2cpp/il2cpp.h>
+
+#include <cstdint>
+
+// The Q-Trials, field training, outposts, daily goals and missions buttons.
+struct MissionsHudViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "MissionsHudViewController">;
+
+  // The buttons are a mix of Button and GenericButtonWidget fields; only their GameObject matters to the mod.
+  template <il2cpp::Name Field> unity::Component* ButtonField()
+  { return this->template Field<Field, unity::Component*>(); }
+};
+
+struct FactionInformation : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "FactionInformation">;
+
+  // TextLocalizer components, one per system name label.
+  il2cpp::List<unity::Component*>* systemName()
+  { return Field<"_systemName", il2cpp::List<unity::Component*>*>(); }
+};
+
+// Timer data contexts, galactic anomalies and navigation view data are read on their runtime classes: the mod only
+// needs a few members, and these classes have moved between client builds.
+struct TimerDataContext : il2cpp::Object {
+  unity::TimeSpan RemainingTime()
+  { return Get<"RemainingTime", unity::TimeSpan>(); }
+};
+
+// Digit.PrimeServer.Models.GalacticAnomaly
+struct GalacticAnomaly : il2cpp::Object {
+  bool IsActive()
+  { return Get<"IsActive", bool>(); }
+  TimerDataContext* EndTimeTimerDataContext()
+  { return Get<"EndTimeTimerDataContext", TimerDataContext*>(); }
+};
+
+struct NodeAddress : il2cpp::Object {
+  int64_t System()
+  { return Get<"System", int64_t>(); }
+};
+
+struct NavigationViewData : il2cpp::Object {
+  NodeAddress* ViewingAddress()
+  { return Get<"ViewingAddress", NodeAddress*>(); }
+};
+
+struct HudNavigationViewController : unity::Component {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation.UI", "HudNavigationViewController">;
+  // The data context its canvas is registered with, for ScreenManager::View.
+  using Context = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationViewData">;
+
+  unity::Component* galacticAnomaliesButtonWidget()
+  { return Field<"_galacticAnomaliesButtonWidget", unity::Component*>(); }
+  FactionInformation* factionInformationHelper()
+  { return Field<"_factionInformationHelper", FactionInformation*>(); }
+  bool isActiveAndEnabled()
+  { return Get<"isActiveAndEnabled", bool>(); }
+  bool CanShowGalacticAnomaly()
+  { return Call<"CanShowGalacticAnomaly", bool>(); }
+  NavigationViewData* CanvasContext()
+  { return Get<"CanvasContext", NavigationViewData*>(); }
+};
+
+// The upper-right drawer with Help All, Engage and Claim.
+struct HudAllianceAndNewsViewController : il2cpp::Object {
+  using Class   = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "HudAllianceAndNewsViewController">;
+  using Context = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "HudAllianceAndNewsViewControllerContext">;
+
+  unity::Component* chestPromotion()
+  { return Field<"_chestPromotion", unity::Component*>(); }
+};
+
+struct GalacticAnomaliesManager : MonoSingleton<GalacticAnomaliesManager> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.GalacticAnomalies", "GalacticAnomaliesManager">;
+
+  // The singleton MonoSingleton`1 already holds, or null when there is none or it was destroyed. Instance would
+  // search the scene, or create a replacement, when there is none.
+  static GalacticAnomaliesManager* Current()
+  {
+    auto* manager = Existing();
+    return unity::Alive(manager) ? manager : nullptr;
+  }
+
+  GalacticAnomaly* GetSystemGalacticAnomalies(int64_t system)
+  { return Call<"GetSystemGalacticAnomalies", GalacticAnomaly*>(system); }
+};
diff --git a/mods/src/prime/inventory.h b/mods/src/prime/inventory.h
new file mode 100644
index 000000000..bf345208a
--- /dev/null
+++ b/mods/src/prime/inventory.h
@@ -0,0 +1,344 @@
+#pragma once
+
+// The inventory, its use and purchase popups, and the shop and gift screens.
+
+#include "prime/server.h"
+#include "prime/ui.h"
+
+#include <il2cpp/il2cpp.h>
+
+#include <cstdint>
+#include <optional>
+
+// The context of a use, purchase or donation popup.
+struct InventoryForPopup : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Inventories", "InventoryForPopup">;
+
+  int64_t MaxItemsToUse()
+  { return Get<"MaxItemsToUse", int64_t>(); }
+  void SetMaxItemsToUse(int64_t value)
+  { Set<"MaxItemsToUse">(value); }
+  bool IsDonationUse()
+  { return Get<"IsDonationUse", bool>(); }
+  int64_t AmountOwned()
+  { return Get<"AmountOwned", int64_t>(); }
+  bool IsChestPurchase()
+  { return Get<"IsChestPurchase", bool>(); }
+};
+
+struct InventoryUseRowWidget : Widget<InventoryForPopup> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Inventories", "InventoryUseRowWidget">;
+};
+
+// The use popup, which also exchanges artifact shards.
+struct InventoryUsePopupViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Inventories", "InventoryUsePopupViewController">;
+
+  // Only artifact bulk conversion uses this button, not the inventory entry button or single exchanges.
+  unity::Component* convertAllButton()
+  { return Field<"_convertAllButton", unity::Component*>(); }
+};
+
+// Also the base of the officer roster and the other inventory-style lists.
+struct InventoryListViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Inventories", "InventoryListViewController">;
+
+  InputFieldWidget* inputField()
+  { return Field<"_inputField", InputFieldWidget*>(); }
+  bool isActiveAndEnabled()
+  { return Get<"isActiveAndEnabled", bool>(); }
+};
+
+struct Bundle : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimePlatform.Content", "Bundle">;
+};
+
+struct ShopListScrollerViewController;
+struct InventoryTooltipTriggerWidget;
+
+// A shop offer.
+struct BundleDataWidget : Widget<Bundle> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Shop", "BundleDataWidget">;
+
+  // ItemState flags; only the one the mod reads is named.
+  static constexpr int32_t kCooldownTimerOn = 16384;
+
+  int32_t CurrentState()
+  { return Field<"_currentState", int32_t>(); }
+  void AuxViewButtonPressedHandler()
+  { Call<"AuxViewButtonPressedHandler">(); }
+
+  // Set by OnDidBindContext after the card set up its tooltip.
+  inline ShopListScrollerViewController* scrollerController();
+  inline InventoryTooltipTriggerWidget*  invTooltip();
+};
+
+struct DrawerContext : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Prime.SharedFeatures.Scripts.UI.Widgets", "DrawerContext">;
+
+  bool Enabled()
+  { return Field<"Enabled", bool>(); }
+};
+
+struct DrawerWidget : Widget<DrawerContext> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Prime.SharedFeatures.Scripts.UI.Widgets", "DrawerWidget">;
+
+  void OnOpenButtonClicked()
+  { Call<"OnOpenButtonClicked">(); }
+};
+
+// The gifts screen; its selection drawer holds bulk claim.
+struct ShopListScrollerViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Shop", "ShopListScrollerViewController">;
+
+  DrawerWidget* selectionDrawerWidget()
+  { return Field<"_selectionDrawerWidget", DrawerWidget*>(); }
+  // Declared as some scroller; the store only uses a SmartScrollerBase.
+  il2cpp::Object* smartScroller()
+  { return Field<"_smartScroller", il2cpp::Object*>(); }
+};
+
+// Digit.Client.Serialization.OverridableBool: the serialized flag and the runtime override.
+struct OverridableBool {
+  bool serialized, current, modified;
+};
+
+struct ActionLocaleSetting : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Actions", "ActionLocaleSetting">;
+};
+
+struct ActionLocaleSettingsList : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Actions", "ActionLocaleSettingsList">;
+};
+
+struct TooltipLoadAndShow : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Tooltip", "TooltipLoadAndShow">;
+};
+
+// TryEnabled and TrySetEnabled tell a failed call from the value, so the store can undo a half-made swap.
+struct TooltipTrigger : unity::Behaviour {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Tooltip", "TooltipTrigger">;
+
+  TooltipLoadAndShow* loader()
+  { return Field<"_loader", TooltipLoadAndShow*>(); }
+  std::optional<bool> TryEnabled()
+  { return TryCall<"get_enabled", bool()>(); }
+  bool TrySetEnabled(bool value)
+  { return TryCall<"set_enabled", void(bool)>(value); }
+
+  // Every serialized appearance field: what to show, where, and how it loads.
+  void CopyAppearance(TooltipTrigger* source)
+  {
+    SetField<"_showHeader">(source->Field<"_showHeader", OverridableBool>());
+    SetField<"_header">(source->Field<"_header", LocaleTextContext*>());
+    SetField<"_showDescription">(source->Field<"_showDescription", OverridableBool>());
+    SetField<"_description">(source->Field<"_description", LocaleTextContext*>());
+    SetField<"_overrideLocale">(source->Field<"_overrideLocale", bool>());
+    // Digit.Client.Tooltip.TooltipAnchor; -1 is Undefined.
+    SetField<"_anchorOverride">(source->Field<"_anchorOverride", int32_t>());
+    SetField<"_sizeOverride">(source->Field<"_sizeOverride", unity::Vector2>());
+    SetField<"_positionOverrideTarget">(source->Field<"_positionOverrideTarget", unity::Transform*>());
+    SetField<"_positionOverrideOffset">(source->Field<"_positionOverrideOffset", unity::Vector2>());
+    SetField<"_isInteractable">(source->Field<"_isInteractable", bool>());
+    SetField<"<DescriptionOverrideText>k__BackingField">(
+        source->Field<"<DescriptionOverrideText>k__BackingField", Il2CppString*>());
+    SetField<"_loader">(source->loader());
+  }
+};
+
+struct TooltipActionTrigger : TooltipTrigger {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Tooltip", "TooltipActionTrigger">;
+};
+
+// What a store tooltip shows. Its members resolve on the runtime class.
+struct TooltipItem : il2cpp::Object {
+  // ResourceSpec.Id; 0 when there is none.
+  int64_t ResourceId()
+  {
+    auto* spec = Get<"ResourceSpec", il2cpp::Object*>();
+    return spec ? spec->Get<"Id", int64_t>() : 0;
+  }
+};
+
+// The tooltip on an inventory or shop item. The Alliance Games store swaps a card's plain trigger for an action
+// trigger that carries the same appearance plus the native research actions, and swaps it back on release.
+struct InventoryTooltipTriggerWidget : unity::Component {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Inventories", "InventoryTooltipTriggerWidget">;
+
+  TooltipItem* Context()
+  { return Get<"Context", TooltipItem*>(); }
+
+  TooltipTrigger* tooltipTrigger()
+  { return Field<"_tooltipTrigger", TooltipTrigger*>(); }
+  void SetTooltipTrigger(TooltipTrigger* value)
+  { SetField<"_tooltipTrigger">(value); }
+  TooltipActionTrigger* tooltipActionTrigger()
+  { return Field<"_tooltipActionTrigger", TooltipActionTrigger*>(); }
+  void SetTooltipActionTrigger(TooltipActionTrigger* value)
+  { SetField<"_tooltipActionTrigger">(value); }
+  ActionLocaleSetting* searchActionLocaleSetting()
+  { return Field<"_searchActionLocaleSetting", ActionLocaleSetting*>(); }
+  void SetSearchActionLocaleSetting(ActionLocaleSetting* value)
+  { SetField<"_searchActionLocaleSetting">(value); }
+  ActionLocaleSetting* actionLocaleSetting()
+  { return Field<"_actionLocaleSetting", ActionLocaleSetting*>(); }
+  void SetActionLocaleSetting(ActionLocaleSetting* value)
+  { SetField<"_actionLocaleSetting">(value); }
+  ActionLocaleSettingsList* settings()
+  { return Field<"_settings", ActionLocaleSettingsList*>(); }
+  void SetSettings(ActionLocaleSettingsList* value)
+  { SetField<"_settings">(value); }
+
+  bool UpdateTooltipDescription()
+  { return TryCall<"UpdateTooltipDescription", void()>(); }
+  bool SetupActionTooltipTrigger()
+  { return TryCall<"SetupActionTooltipTrigger", void()>(); }
+
+  // The plain trigger on this GameObject; null when it is missing or is already an action trigger.
+  TooltipTrigger* PlainTrigger()
+  {
+    auto* object  = gameObject();
+    auto* trigger = object ? object->GetComponent<TooltipTrigger>() : nullptr;
+    return trigger && trigger->klass == TooltipTrigger::Class::Raw() ? trigger : nullptr;
+  }
+  // The action trigger on this GameObject. Empty when the lookup failed, which is not the same as there being none.
+  std::optional<TooltipActionTrigger*> ActionTrigger()
+  {
+    auto* object = gameObject();
+    auto* type   = TooltipActionTrigger::Class::TypeObject();
+    if (!object || !type)
+      return std::nullopt;
+    return object->TryCall<"GetComponent", TooltipActionTrigger*(Il2CppReflectionType*)>(type);
+  }
+  TooltipActionTrigger* AddActionTrigger()
+  {
+    auto* object = gameObject();
+    return object ? object->AddComponent<TooltipActionTrigger>() : nullptr;
+  }
+};
+
+// The smart scroller's card pool and layout.
+struct SmartScrollerBase : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "SmartScrollerBase">;
+
+  // The spawned card transforms.
+  il2cpp::List<unity::Component*>* spawnedItems()
+  { return Field<"_spawnedItems", il2cpp::List<unity::Component*>*>(); }
+  // Cards are still spawning while any of these is set.
+  bool regeneratingContent()
+  { return Field<"_regeneratingContent", bool>(); }
+  il2cpp::Object* spawnerCoroutine()
+  { return Field<"_spawnerCoroutine", il2cpp::Object*>(); }
+  il2cpp::Object* dataHeldWhilstInitializing()
+  { return Field<"_dataHeldWhilstInitializing", il2cpp::Object*>(); }
+
+  std::optional<unity::Vector2> NormalizedPosition()
+  { return TryCall<"get_NormalizedPosition", unity::Vector2()>(); }
+  // Lays the visible cards out again for `position`, as a scroll to it would.
+  bool OnValueChangedCallback(unity::Vector2 position)
+  { return TryCall<"OnValueChangedCallback", void(unity::Vector2)>(position); }
+  std::optional<int32_t> VisibleItemsCount()
+  { return TryCall<"get_VisibleItemsCount", int32_t()>(); }
+  std::optional<float> ScrollPosition()
+  { return TryCall<"get_ScrollPosition", float()>(); }
+
+  // The tooltip widget on a spawned card, active or not.
+  static InventoryTooltipTriggerWidget* CardTooltip(unity::Component* card)
+  {
+    auto* type = InventoryTooltipTriggerWidget::Class::TypeObject();
+    return type ? card->Call<"GetComponentInChildren", InventoryTooltipTriggerWidget*(Il2CppReflectionType*, bool)>(
+                      type, true)
+                : nullptr;
+  }
+};
+
+// The store's context. Its members resolve on the runtime class.
+struct AllianceGamesStoreContext : il2cpp::Object {
+  bool IsShopViewActive()
+  { return Get<"IsShopViewActive", bool>(); }
+  std::optional<bool> IsFetchingBundlesInProgress()
+  { return TryCall<"get_IsFetchingBundlesInProgress", bool()>(); }
+  int32_t BundlesCount()
+  { return Get<"BundlesCount", int32_t>(); }
+  // How many soft currencies the store shows.
+  std::optional<int32_t> CurrencyCount()
+  {
+    auto* currencies = Get<"StoreCurrency", il2cpp::Object*>();
+    auto* soft       = currencies ? currencies->Get<"SoftResources", il2cpp::List<il2cpp::Object*>*>() : nullptr;
+    return soft ? soft->TryCall<"get_Count", int32_t()>() : std::nullopt;
+  }
+  // Rebuilds the store's currency list from its bundles.
+  bool UpdateStoreCurrency()
+  { return TryCall<"UpdateStoreCurrency", void()>(); }
+};
+
+struct AllianceGamesStoreScrollerViewController : ShopListScrollerViewController {
+  using Class =
+      il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Alliances.Games", "AllianceGamesStoreScrollerViewController">;
+
+  AllianceGamesStoreContext* AllianceGamesContext()
+  { return Get<"AllianceGamesContext", AllianceGamesStoreContext*>(); }
+};
+
+ShopListScrollerViewController* BundleDataWidget::scrollerController()
+{ return Field<"_scrollerController", ShopListScrollerViewController*>(); }
+InventoryTooltipTriggerWidget* BundleDataWidget::invTooltip()
+{ return Field<"_invTooltip", InventoryTooltipTriggerWidget*>(); }
+
+// Whether the client still has every field the store reads or writes. The store swaps tooltip components through
+// these, so it does not install where one would read as zero.
+inline bool AllianceGamesStoreFieldsPresent()
+{
+  using Widget   = InventoryTooltipTriggerWidget::Class;
+  using Trigger  = TooltipTrigger::Class;
+  using Scroller = SmartScrollerBase::Class;
+  using Card     = BundleDataWidget::Class;
+  return Widget::HasField<"_tooltipTrigger", TooltipTrigger*>()
+         & Widget::HasField<"_tooltipActionTrigger", TooltipActionTrigger*>()
+         & Widget::HasField<"_searchActionLocaleSetting", ActionLocaleSetting*>()
+         & Widget::HasField<"_actionLocaleSetting", ActionLocaleSetting*>()
+         & Widget::HasField<"_settings", ActionLocaleSettingsList*>()
+         & Trigger::HasField<"_showHeader", OverridableBool>()
+         & Trigger::HasField<"_showDescription", OverridableBool>() & Trigger::HasField<"_header", LocaleTextContext*>()
+         & Trigger::HasField<"_description", LocaleTextContext*>() & Trigger::HasField<"_overrideLocale", bool>()
+         & Trigger::HasField<"_anchorOverride", int32_t>() & Trigger::HasField<"_sizeOverride", unity::Vector2>()
+         & Trigger::HasField<"_positionOverrideOffset", unity::Vector2>()
+         & Trigger::HasField<"_positionOverrideTarget", unity::Transform*>()
+         & Trigger::HasField<"_isInteractable", bool>()
+         & Trigger::HasField<"<DescriptionOverrideText>k__BackingField", Il2CppString*>()
+         & Trigger::HasField<"_loader", TooltipLoadAndShow*>()
+         & ShopListScrollerViewController::Class::HasField<"_smartScroller", il2cpp::Object*>()
+         & Scroller::HasField<"_spawnedItems", il2cpp::List<unity::Component*>*>()
+         & Card::HasField<"_invTooltip", InventoryTooltipTriggerWidget*>()
+         & Card::HasField<"_scrollerController", ShopListScrollerViewController*>()
+         & Scroller::HasField<"_regeneratingContent", bool>()
+         & Scroller::HasField<"_spawnerCoroutine", il2cpp::Object*>()
+         & Scroller::HasField<"_dataHeldWhilstInitializing", il2cpp::Object*>();
+}
+
+using ShopSceneManager = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Shop", "ShopSceneManager">;
+
+struct InterstitialViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Interstitial", "InterstitialViewController">;
+  void CloseWhenReady()
+  { Call<"CloseWhenReady">(); }
+};
+
+// The forbidden tech inventory tiles and the large selected-item panel.
+struct ForbiddenTechInventoryItemWidget : Widget<InventoryItem> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ForbiddenTechs", "ForbiddenTechInventoryItemWidget">;
+
+  // ForbiddenTechInventoryItemWidget.WidgetType.
+  enum class Type : int32_t {
+    ScrollerEntry = 0,
+    LargeShowcase = 1,
+  };
+
+  Type widgetType()
+  { return Field<"_widgetType", Type>(); }
+  // SmartScroller
+  unity::Component* buffListScroller()
+  { return Field<"_buffListScroller", unity::Component*>(); }
+  TextLocalizer* name()
+  { return Field<"_name", TextLocalizer*>(); }
+};
diff --git a/mods/src/prime/loading.h b/mods/src/prime/loading.h
new file mode 100644
index 000000000..29d6b175d
--- /dev/null
+++ b/mods/src/prime/loading.h
@@ -0,0 +1,38 @@
+#pragma once
+
+// The login screen, the transition screen shown between sections, and their loading tips and slide shows.
+
+#include "prime/ui.h"
+
+#include <il2cpp/il2cpp.h>
+
+struct LoginSequence : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Login", "LoginSequence">;
+
+  unity::Component* mainCanvas()
+  { return Field<"_mainCanvas", unity::Component*>(); }
+};
+
+struct LoadingTipViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Prime.LoadingScreen", "LoadingTipViewController">;
+
+  unity::TMP_Text* textMeshPro()
+  { return Field<"_textMeshPro", unity::TMP_Text*>(); }
+};
+
+struct TransitionViewController : unity::Component {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.LoadingScreen", "TransitionViewController">;
+
+  unity::Image* staticOverride()
+  { return Field<"_staticOverride", unity::Image*>(); }
+  // The canvas Animator; Behaviour is enough to toggle it.
+  unity::Behaviour* animator()
+  { return Field<"_animator", unity::Behaviour*>(); }
+};
+
+struct SlideShowViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.SlideShow", "SlideShowViewController">;
+
+  unity::Image* image()
+  { return Field<"_image", unity::Image*>(); }
+};
diff --git a/mods/src/prime/missions.h b/mods/src/prime/missions.h
new file mode 100644
index 000000000..062d1c8ef
--- /dev/null
+++ b/mods/src/prime/missions.h
@@ -0,0 +1,21 @@
+#pragma once
+
+// The missions screen and its daily goals.
+
+#include "prime/server.h"
+
+#include <il2cpp/il2cpp.h>
+#include <unity/ui.h>
+
+// An ITournament from the missions screen's claimable dailies; today an EventModel. Read on its runtime class.
+struct DailyGoal : il2cpp::Object {
+  il2cpp::List<InventoryItem*>* factionPointRewards()
+  { return Field<"_factionPointRewards", il2cpp::List<InventoryItem*>*>(); }
+};
+
+struct MissionViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Missions", "MissionViewController">;
+
+  unity::Toggle* claimAllToggle()
+  { return Field<"_claimAllToggle", unity::Toggle*>(); }
+};
diff --git a/mods/src/prime/navigation.h b/mods/src/prime/navigation.h
new file mode 100644
index 000000000..40e208064
--- /dev/null
+++ b/mods/src/prime/navigation.h
@@ -0,0 +1,312 @@
+#pragma once
+
+// System and galaxy navigation: camera zoom and pan, LOD, sections, bookmarks, course prompts.
+
+#include "prime/Hub.h"
+#include "prime/fleet.h"
+#include "prime/ui.h"
+
+#include <il2cpp/il2cpp.h>
+
+#include <cstdint>
+
+enum class ZoomLevels {
+  None   = 0,
+  Near   = 1,
+  Middle = 2,
+  Far    = 3,
+};
+
+struct NavigationLOD : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationLOD">;
+
+  void UpdateLOD(ZoomLevels level)
+  { Call<"UpdateLOD">(level); }
+
+  // Writes the backing field directly; the managed setter is private.
+  void SetTargetLevel(ZoomLevels level)
+  { SetField<"<TargetLevel>k__BackingField">(level); }
+};
+
+struct NavigationPan : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationPan">;
+
+  void MoveCamera(unity::Vector2 delta, bool isMomentum = false)
+  { Call<"MoveCamera">(delta, isMomentum); }
+
+  static bool BlockPan()
+  { return Class::Field<"BlockPan", bool>(); }
+
+  unity::Vector2 lastDelta()
+  { return Field<"_lastDelta", unity::Vector2>(); }
+  void SetLastDelta(unity::Vector2 value)
+  { SetField<"_lastDelta">(value); }
+  bool panningStarted()
+  { return Field<"_panningStarted", bool>(); }
+  float deltaScaler()
+  { return Field<"_deltaScaler", float>(); }
+  float keyboardDeltaScaler()
+  { return Field<"_keyboardDeltaScaler", float>(); }
+  // Managed POI; only checked for null or cleared.
+  void* trackingPOI()
+  { return Field<"_trackingPOI", void*>(); }
+  void SetTrackingPOI(void* value)
+  { SetField<"_trackingPOI">(value); }
+
+  float farMagRadiusRatioSystemNormal()
+  { return Field<"_farMagRadiusRatioSystemNormal", float>(); }
+  void SetFarMagRadiusRatioSystemExtended(float value)
+  { SetField<"_farMagRadiusRatioSystemExtended">(value); }
+};
+
+enum class NodeDepth : int32_t {
+  Galaxy       = 1,
+  SolarSystem  = 2,
+  PlanetSystem = 4,
+  Starbase     = 8,
+};
+
+struct MathUtils {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.Client.Core", "MathUtils">;
+
+  // The world point under the screen position `mouse`, as seen by `camera`.
+  static unity::Vector3 GetMouseWorldPos(unity::Camera* camera, unity::Vector3 mouse)
+  { return Class::Call<"GetMouseWorldPos", unity::Vector3>(camera, mouse); }
+};
+
+struct NavigationZoom : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationZoom">;
+
+  void ZoomCameraAtWorldPoint()
+  { Call<"ZoomCameraAtWorldPoint">(); }
+
+  float Distance()
+  { return Get<"Distance", float>(); }
+  void SetDistance(float value)
+  { Set<"Distance">(value); }
+  float NormalizedZoom()
+  { return Get<"NormalizedZoom", float>(); }
+
+  NodeDepth depth()
+  { return Field<"_depth", NodeDepth>(); }
+  ZoomLevels zoomLevel()
+  { return Field<"_zoomLevel", ZoomLevels>(); }
+  unity::Camera* sceneCamera()
+  { return Field<"_sceneCamera", unity::Camera*>(); }
+
+  void SetZoomtotal(float value)
+  { SetField<"_zoomtotal">(value); }
+  float minimum()
+  { return Field<"_minimum", float>(); }
+  float maximum()
+  { return Field<"_maximum", float>(); }
+  void SetMaximum(float value)
+  { SetField<"_maximum">(value); }
+  void SetZoomDelta(float value)
+  { SetField<"_zoomDelta">(value); }
+  float viewRadius()
+  { return Field<"_viewRadius", float>(); }
+  void SetLastZoomDelta(float value)
+  { SetField<"_lastZoomDelta">(value); }
+  void SetZoomLocation(unity::Vector2 value)
+  { SetField<"_zoomLocation">(value); }
+  void SetWorldPoint(unity::Vector3 value)
+  { SetField<"_worldPoint">(value); }
+  void SetFarRatioSystemNormal(float value)
+  { SetField<"_farRatioSystemNormal">(value); }
+  void SetFarRatioSystemExtended(float value)
+  { SetField<"_farRatioSystemExtended">(value); }
+};
+
+struct NavigationFleetWidget : Widget<FleetDeployedData> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationFleetWidget">;
+
+  NavigationLOD* lod()
+  { return Field<"_lod", NavigationLOD*>(); }
+};
+
+struct NavigationManager : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationManager">;
+
+  void HideInteraction()
+  { Call<"HideInteraction">(); }
+};
+
+struct NavigationSectionManager : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationSectionManager">;
+
+  static void ChangeNavigationSection(SectionID sectionId, int64_t systemId = -1)
+  { Class::Call<"ChangeNavigationSection">(sectionId, systemId); }
+
+  static NavigationSectionManager* Instance()
+  { return Class::Get<"Instance", NavigationSectionManager*>(); }
+
+  // Not NavigationManager(): that would hide the type inside this struct.
+  NavigationManager* SNavigationManager()
+  { return Get<"NavigationManager", NavigationManager*>(); }
+
+  // Closes whatever interaction menu is open in space before the mod acts on a fleet.
+  static void HideInteraction()
+  {
+    auto* section = Instance();
+    if (auto* navigation = section ? section->SNavigationManager() : nullptr)
+      navigation->HideInteraction();
+  }
+};
+
+struct NavigationInteractionUIContext : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationInteractionUIContext">;
+};
+
+struct SetCourseWidget : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "SetCourseWidget">;
+  VisibilityController* visibilityController()
+  { return Field<"_visibilityController", VisibilityController*>(); }
+  bool isActiveAndEnabled()
+  { return Get<"isActiveAndEnabled", bool>(); }
+  SemaphoreButtonListener* joinWaveDefenseButton()
+  { return Field<"_joinWaveDefenseButton", SemaphoreButtonListener*>(); }
+};
+
+struct NavigationInteractionUIViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "NavigationInteractionUIViewController">;
+
+  bool TryPressJoinWaveDefense()
+  {
+    if (!IsSetCourseVisible()) {
+      return false;
+    }
+    auto* widget   = Field<"_setCourseWidget", SetCourseWidget*>();
+    auto* listener = widget ? widget->joinWaveDefenseButton() : nullptr;
+    if (!listener || !listener->isActiveAndEnabled()) {
+      return false;
+    }
+    // Button.Press preserves Unity's active/interactable checks and the native join callback.
+    listener->Press();
+    return true;
+  }
+
+  bool IsSetCourseVisible()
+  {
+    auto* widget     = Field<"_setCourseWidget", SetCourseWidget*>();
+    auto* visibility = widget ? widget->visibilityController() : nullptr;
+    return visibility
+           && (visibility->state() == VisibilityState::Visible || visibility->state() == VisibilityState::Show)
+           && widget->isActiveAndEnabled();
+  }
+  void OnSetCourseButtonClick()
+  { Call<"OnSetCourseButtonClick">(); }
+};
+
+struct OrbitFrameProvider : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.CameraController", "OrbitFrameProvider">;
+
+  // Declared on AbstractOrbitFrameProvider.
+  float RotationAngleDelta()
+  { return Field<"_rotationAngleDelta", float>(); }
+  void SetRotationAngleDelta(float value)
+  { SetField<"_rotationAngleDelta">(value); }
+};
+
+struct PlanetViewUtils : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "PlanetViewUtils">;
+
+  // The planet's 2D sprite, a Component. Calling this also runs any detour on get_FlatRenderable.
+  unity::Component* FlatRenderable()
+  { return static_cast<unity::Component*>(Get<"FlatRenderable", Il2CppObject*>()); }
+};
+
+struct CoordinateSearchContext : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Bookmarks", "CoordinateSearchContext">;
+
+  void SetDefaultXCoordinate(Il2CppString* value)
+  { Set<"DefaultXCoordinate">(value); }
+  void SetDefaultYCoordinate(Il2CppString* value)
+  { Set<"DefaultYCoordinate">(value); }
+  void SetDefaultSystemInput(Il2CppString* value)
+  { Set<"DefaultSystemInput">(value); }
+};
+
+struct BookmarksManager : MonoSingleton<BookmarksManager> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Bookmarks", "BookmarksManager">;
+
+  void ViewBookmarks()
+  { Call<"ViewBookmarks">(); }
+
+  void ViewCoordinateSearch()
+  {
+    auto* context = il2cpp::New<CoordinateSearchContext>();
+    // The binding already reported the missing class or constructor; plain bookmarks are the next best view.
+    if (!context) {
+      ViewBookmarks();
+      return;
+    }
+
+    auto* zero = il2cpp::NewString("0");
+    context->SetDefaultXCoordinate(zero);
+    context->SetDefaultYCoordinate(zero);
+    context->SetDefaultSystemInput(il2cpp::NewString(""));
+    Hub::Sections()->TriggerSectionChange(SectionID::Bookmarks_Search_Coordinates, context, false, false, true);
+  }
+};
+
+struct CoursePromptPopupDataContext : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "CoursePromptPopupDataContext">;
+
+  bool HasInstantWarp()
+  { return Field<"HasInstantWarp", bool>(); }
+  CourseData* GetCourseData()
+  { return Field<"CourseData", CourseData*>(); }
+};
+
+struct CoursePromptPopupWidget : Widget<CoursePromptPopupDataContext> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Navigation", "CoursePromptPopupWidget">;
+
+  void InitiateRegularWarp()
+  { Call<"InitiateRegularWarp">(); }
+  void OnInstantWarpButtonClick()
+  { Call<"OnInstantWarpButtonClick">(); }
+};
+
+struct CoursePromptPopupViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "CoursePromptPopupViewController">;
+
+  CoursePromptPopupWidget* PopupWidget()
+  { return Field<"_coursePromptPopupWidget", CoursePromptPopupWidget*>(); }
+};
+
+// TouchKit's touch; a held touch reports Stationary, which the pan ignores.
+struct TKTouch : il2cpp::Object {
+  using Class = il2cpp::Class<"TouchKit", "", "TKTouch">;
+
+  unity::TouchPhase phase()
+  { return Field<"phase", unity::TouchPhase>(); }
+  void SetPhase(unity::TouchPhase phase)
+  { SetField<"phase">(phase); }
+};
+
+struct InteriorRadiusConstraint : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.CameraController", "Constraint/FloatData">;
+  bool Enabled()
+  { return Field<"_enabled", bool>(); }
+  float Minimum()
+  { return Field<"_min", float>(); }
+  float Maximum()
+  { return Field<"_max", float>(); }
+  void SetMinimum(float value)
+  { SetField<"_min">(value); }
+  void SetMaximum(float value)
+  { SetField<"_max">(value); }
+};
+
+struct InteriorOrbitConstraint : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.CameraController", "OrbitConstraint">;
+  InteriorRadiusConstraint* Radius()
+  { return Field<"_radius", InteriorRadiusConstraint*>(); }
+};
+
+struct InteriorOrbitProvider : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.CameraController", "AbstractOrbitFrameProvider">;
+  InteriorOrbitConstraint* Constraint()
+  { return Field<"_constraint", InteriorOrbitConstraint*>(); }
+};
diff --git a/mods/src/prime/officers.h b/mods/src/prime/officers.h
new file mode 100644
index 000000000..fa390e9e5
--- /dev/null
+++ b/mods/src/prime/officers.h
@@ -0,0 +1,61 @@
+#pragma once
+
+// The officer roster and officer assignment screens, and the sort options their lists offer.
+
+#include "prime/ui.h"
+
+#include <il2cpp/il2cpp.h>
+
+struct OfficerAssignmentViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.OfficerAssignment", "OfficerAssignmentViewController">;
+
+  InputFieldWidget* inputField()
+  { return Field<"_inputField", InputFieldWidget*>(); }
+  GenericButtonWidget* officerPresetsButton()
+  { return Field<"_officerPresetsButton", GenericButtonWidget*>(); }
+  bool isActiveAndEnabled()
+  { return Get<"isActiveAndEnabled", bool>(); }
+};
+
+// The static comparers the officer lists sort with.
+using SortingPredicates = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Core", "SortingPredicates">;
+
+struct SortFunction : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.Client.Core", "SortFunction">;
+
+  // Func<object, object, int> delegates.
+  il2cpp::Object* ascending()
+  { return Field<"_ascending", il2cpp::Object*>(); }
+  void SetAscending(Il2CppObject* value)
+  { SetField<"_ascending">(value); }
+  void SetDescending(Il2CppObject* value)
+  { SetField<"_descending">(value); }
+  void SetDisplayKey(Il2CppString* value)
+  { SetField<"_displayKey">(value); }
+};
+
+// One entry in a list's sort menu.
+struct ProcessingOption : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Sorting", "SortComparer/ProcessingOption">;
+
+  Il2CppString* displayKey()
+  { return Field<"_displayKey", Il2CppString*>(); }
+  void SetDisplayKey(Il2CppString* value)
+  { SetField<"_displayKey">(value); }
+  SortFunction* sortingOption()
+  { return Field<"_sortingOption", SortFunction*>(); }
+  void SetSortingOption(SortFunction* value)
+  { SetField<"_sortingOption">(value); }
+};
+
+// Builds the sort menus of the officer roster and the officer assignment screen.
+struct OfficerSortGenerators : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Officers", "OfficerSortGenerators">;
+
+  il2cpp::List<SortFunction*>* rosterSorters()
+  { return Field<"_rosterSorters", il2cpp::List<SortFunction*>*>(); }
+  il2cpp::List<ProcessingOption*>* rosterOptions()
+  { return Field<"_rosterOptions", il2cpp::List<ProcessingOption*>*>(); }
+  il2cpp::List<ProcessingOption*>* assignmentOptions()
+  { return Field<"_assignmentOptions", il2cpp::List<ProcessingOption*>*>(); }
+};
diff --git a/mods/src/prime/queues.h b/mods/src/prime/queues.h
new file mode 100644
index 000000000..fb0e76d7c
--- /dev/null
+++ b/mods/src/prime/queues.h
@@ -0,0 +1,632 @@
+#pragma once
+// Checked queue metadata and storage access. Unknown layouts retain native behavior.
+#include "patches/action_queue_guard_policy.h"
+#include "patches/parts/action_queue.h"
+#include "patches/queue_address_guard_policy.h"
+#include <array>
+#include <cstring>
+#include <il2cpp/il2cpp.h>
+#include <il2cpp/method_contract.h>
+#include <spdlog/spdlog.h>
+#include <utility>
+
+namespace queue_bindings::recovery
+{
+using Object = Il2CppObject;
+using Id     = std::int64_t;
+using action_queue::QueueState;
+inline Il2CppClass *queueClass{}, *actionClass{}, *int64Class{};
+
+struct WeakQueues {
+  using Object = Il2CppObject*;
+  using Handle = Il2CppGCHandle;
+  static Handle New(Object value)
+  { return il2cpp_gchandle_new_weakref(value, false); }
+  static Object Get(Handle handle)
+  { return il2cpp_gchandle_get_target(handle); }
+  static void Free(Handle handle)
+  { il2cpp_gchandle_free(handle); }
+};
+
+template <typename T> T Read(const void* object, std::size_t offset)
+{
+  T value{};
+  if (object)
+    std::memcpy(&value, static_cast<const char*>(object) + offset, sizeof(value));
+  return value;
+}
+// Inspect actual List<QueueableAction> storage without invoking game properties or enumerators.
+// Unknown storage/layout is ineligible, never equivalent to an empty queue or absent target.
+inline QueueState Inspect(Il2CppObject* queue, std::int64_t target = 0)
+{
+  QueueState s;
+  if (!queue || il2cpp_object_get_class(queue) != queueClass)
+    return s;
+  s.fleet    = Read<std::int64_t>(queue, 0x30);
+  s.attempt  = Read<float>(queue, 0x14);
+  s.engaging = Read<bool>(queue, 0x10);
+  auto* list = Read<Il2CppObject*>(queue, 0x28);
+  if (!list)
+    return s;
+  auto* cls     = il2cpp_object_get_class(list);
+  auto* size    = il2cpp_class_get_field_from_name(cls, "_size");
+  auto* storage = il2cpp_class_get_field_from_name(cls, "_items");
+  if (!size || !storage || !size->type || !storage->type || size->type->type != IL2CPP_TYPE_I4
+      || storage->type->type != IL2CPP_TYPE_SZARRAY || size->type->byref || storage->type->byref
+      || (il2cpp_field_get_flags(size) & FIELD_ATTRIBUTE_STATIC)
+      || (il2cpp_field_get_flags(storage) & FIELD_ATTRIBUTE_STATIC))
+    return s;
+  Il2CppArray* items{};
+  il2cpp_field_get_value(list, size, &s.count);
+  il2cpp_field_get_value(list, storage, &items);
+  if (s.count < 0 || s.count > 128 || !items || il2cpp_array_length(items) < static_cast<unsigned>(s.count)
+      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Il2CppObject*>(items))) != actionClass)
+    return s;
+  auto*      array        = reinterpret_cast<Il2CppArraySize*>(items);
+  const auto inspectCount = target ? s.count : (s.count > 0 ? 1 : 0);
+  for (int i = 0; i < inspectCount; ++i) {
+    auto* action = static_cast<Il2CppObject*>(array->vector[i]);
+    if (!action || il2cpp_object_get_class(action) != actionClass)
+      return s;
+    const auto id = Read<std::int64_t>(action, 0x10);
+    if (i == 0)
+      s.front = id;
+    if (target && id == target)
+      s.containsTarget = true;
+  }
+  s.valid = s.fleet != 0;
+  return s;
+}
+inline Il2CppArraySize* Queues(Il2CppObject* manager)
+{
+  auto* array = Read<Il2CppArray*>(manager, 0x48);
+  if (!array || il2cpp_array_length(array) > 64
+      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Il2CppObject*>(array))) != queueClass)
+    return nullptr;
+  return reinterpret_cast<Il2CppArraySize*>(array);
+}
+inline Il2CppObject* FindQueue(Il2CppObject* manager, std::int64_t fleet)
+{
+  auto* array = Queues(manager);
+  if (!array)
+    return nullptr;
+  for (unsigned i = 0; i < array->max_length; ++i) {
+    auto* queue = static_cast<Il2CppObject*>(array->vector[i]);
+    if (queue && il2cpp_object_get_class(queue) == queueClass && Read<std::int64_t>(queue, 0x30) == fleet)
+      return queue;
+  }
+  return nullptr;
+}
+inline bool AbsentFromAllQueues(Il2CppObject* manager, std::int64_t target)
+{
+  auto* array = Queues(manager);
+  if (!array)
+    return false;
+  for (unsigned i = 0; i < array->max_length; ++i) {
+    auto* queue = static_cast<Il2CppObject*>(array->vector[i]);
+    if (!queue)
+      continue;
+    const auto s = Inspect(queue, target);
+    if (!s.valid || s.containsTarget)
+      return false;
+  }
+  return true;
+}
+
+inline bool Field(Il2CppClass* cls, const char* name, std::ptrdiff_t offset, Il2CppTypeEnum type)
+{
+  auto*      field = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
+  const bool valid = field && field->offset == offset && field->type && !field->type->byref
+                     && !(il2cpp_field_get_flags(field) & FIELD_ATTRIBUTE_STATIC) && field->type->type == type;
+  if (!valid)
+    spdlog::warn("[FasterQueueRecovery] {}.{}: expected instance field offset=0x{:X} type={}; "
+                 "actual offset={} type={} static={} byref={}",
+                 cls ? cls->name : "<missing class>", name, offset, static_cast<int>(type), field ? field->offset : -1,
+                 field && field->type ? static_cast<int>(field->type->type) : -1,
+                 field && field->type && bool(il2cpp_field_get_flags(field) & FIELD_ATTRIBUTE_STATIC),
+                 field && field->type && bool(field->type->byref));
+  return valid;
+}
+
+struct CourseResponse {
+  std::int64_t  fleet;
+  bool          success, recall;
+  unsigned char padding[6];
+  Il2CppObject* target;
+};
+static_assert(sizeof(CourseResponse) == 24 && offsetof(CourseResponse, target) == 16);
+
+inline void* engage{};
+inline void* retry{};
+inline void* course{};
+inline void* clear{};
+inline bool  ResolveBindings()
+{
+  auto* cls   = il2cpp::Class<"Assembly-CSharp", "Prime.ActionQueue", "ActionQueueManager">::Raw();
+  queueClass  = il2cpp::Class<"Assembly-CSharp", "Prime.ActionQueue", "ActionQueueInstance">::Raw();
+  actionClass = il2cpp::Class<"Assembly-CSharp", "Prime.ActionQueue", "QueueableAction">::Raw();
+  int64Class  = il2cpp::Class<"mscorlib", "System", "Int64">::Raw();
+  if (!cls || !queueClass || !actionClass || !int64Class) {
+    for (const auto& [type, name] :
+         std::array{std::pair{cls, "Prime.ActionQueue.ActionQueueManager"},
+                    std::pair{queueClass, "Prime.ActionQueue.ActionQueueInstance"},
+                    std::pair{actionClass, "Prime.ActionQueue.QueueableAction"}, std::pair{int64Class, "System.Int64"}})
+      if (!type)
+        spdlog::warn("[FasterQueueRecovery] unavailable: missing class {}", name);
+    return false;
+  }
+  using il2cpp::contract::Pointer;
+  using il2cpp::contract::Resolve;
+  const auto* engage_info =
+      Resolve(cls, "TryPlanPathAndEngageTarget", false, "Digit.Prime.Combat.EngageResult",
+              {"Digit.PrimeServer.Models.FleetPlayerData", "Prime.ActionQueue.ActionQueueInstance"});
+  engage                   = Pointer(engage_info);
+  const auto* retry_info   = Resolve(cls, "ShouldRetryFailedSetCourse", false, "System.Boolean",
+                                     {"System.Int64", "Prime.ActionQueue.ActionQueueInstance"});
+  retry                    = Pointer(retry_info);
+  const auto* clear_info   = Resolve(cls, "StopWatchdogAndClearAllQueues", false, "System.Void", {});
+  clear                    = Pointer(clear_info);
+  const auto* info         = Resolve(cls, "OnSetCourseResponseEventHandler", false, "System.Void",
+                                     {"Digit.PrimeServer.Events.SetCourseResponseEventArgs"});
+  course                   = Pointer(info);
+  auto*         event      = info ? il2cpp_class_from_type(info->parameters[0]) : nullptr;
+  auto*         result     = engage_info ? il2cpp_class_from_type(engage_info->return_type) : nullptr;
+  const auto*   underlying = result && il2cpp_class_is_enum(result) ? il2cpp_class_enum_basetype(result) : nullptr;
+  std::uint32_t alignment{};
+  const bool    valid =
+      underlying && underlying->type == IL2CPP_TYPE_I4 && event && info->parameters[0]->type == IL2CPP_TYPE_VALUETYPE
+      && il2cpp_class_value_size(event, &alignment) == sizeof(CourseResponse)
+      && Field(event, "<FleetId>k__BackingField", 0x10, IL2CPP_TYPE_I8)
+      && Field(event, "<Success>k__BackingField", 0x18, IL2CPP_TYPE_BOOLEAN)
+      && Field(event, "<IsRecall>k__BackingField", 0x19, IL2CPP_TYPE_BOOLEAN)
+      && Field(event, "<TargetId>k__BackingField", 0x20, IL2CPP_TYPE_OBJECT)
+      && Field(cls, "_battleQueue", 0x48, IL2CPP_TYPE_SZARRAY)
+      && Field(queueClass, "IsEngaging", 0x10, IL2CPP_TYPE_BOOLEAN)
+      && Field(queueClass, "LastEngageAttemptTime", 0x14, IL2CPP_TYPE_R4)
+      && Field(queueClass, "<PlayerFleetId>k__BackingField", 0x30, IL2CPP_TYPE_I8)
+      && Field(queueClass, "_actionQueue", 0x28, IL2CPP_TYPE_GENERICINST)
+      && Field(actionClass, "<FleetId>k__BackingField", 0x10, IL2CPP_TYPE_I8) && engage && retry && course && clear
+      && !engage_info->has_full_generic_sharing_signature && !retry_info->has_full_generic_sharing_signature
+      && !info->has_full_generic_sharing_signature && !clear_info->has_full_generic_sharing_signature && engage != retry
+      && engage != course && engage != clear && retry != course && retry != clear && course != clear;
+  if (!valid) {
+    const std::array methods{
+        std::pair{
+            engage_info,
+            "ActionQueueManager.TryPlanPathAndEngageTarget(FleetPlayerData, ActionQueueInstance) -> EngageResult"},
+        std::pair{retry_info, "ActionQueueManager.ShouldRetryFailedSetCourse(Int64, ActionQueueInstance) -> Boolean"},
+        std::pair{info, "ActionQueueManager.OnSetCourseResponseEventHandler(SetCourseResponseEventArgs) -> Void"},
+        std::pair{clear_info, "ActionQueueManager.StopWatchdogAndClearAllQueues() -> Void"}};
+    for (const auto& [method, name] : methods)
+      if (!method || !method->methodPointer || method->has_full_generic_sharing_signature)
+        spdlog::warn("[FasterQueueRecovery] unavailable: {}: {}", name,
+                     method && method->has_full_generic_sharing_signature ? "unsupported generic sharing"
+                                                                          : "instance method unavailable");
+    if (!underlying || underlying->type != IL2CPP_TYPE_I4)
+      spdlog::warn("[FasterQueueRecovery] unavailable: EngageResult must be an Int32 enum");
+    const auto event_size =
+        event && info->parameters[0]->type == IL2CPP_TYPE_VALUETYPE ? il2cpp_class_value_size(event, &alignment) : -1;
+    if (event_size != sizeof(CourseResponse))
+      spdlog::warn(
+          "[FasterQueueRecovery] unavailable: SetCourseResponseEventArgs expected value type size={}; actual={}",
+          sizeof(CourseResponse), event_size);
+    for (size_t i = 0; i < methods.size(); ++i)
+      for (size_t j = 0; j < i; ++j)
+        if (methods[i].first && methods[j].first && methods[i].first->methodPointer
+            && methods[i].first->methodPointer == methods[j].first->methodPointer)
+          spdlog::warn("[FasterQueueRecovery] unavailable: {} and {} share a native hook target", methods[i].second,
+                       methods[j].second);
+    return false;
+  }
+  return true;
+}
+
+inline bool ReadCourseTarget(Il2CppObject* value, int64_t& target)
+{
+  if (!value || il2cpp_object_get_class(value) != int64Class)
+    return false;
+  std::memcpy(&target, il2cpp_object_unbox(value), sizeof(target));
+  return true;
+}
+
+} // namespace queue_bindings::recovery
+namespace queue_bindings::thin
+{
+using Object = Il2CppObject;
+using Id     = std::int64_t;
+using action_queue_guard::QueueState;
+inline Il2CppClass *queueClass{}, *actionClass{}, *playerClass{}, *deployedClass{};
+
+inline Id (*playerId)(Object*);
+
+inline Id (*deployedId)(Object*);
+
+inline int (*playerState)(Object*);
+
+inline int (*deployedState)(Object*);
+
+inline int (*removalReason)(Object*);
+
+inline bool (*destroyed)(Object*);
+
+inline bool (*battling)(Object*);
+
+inline int (*tryEngage)(Object*, Object*, Object*);
+
+inline void (*processTarget)(Object*, Id, bool);
+
+inline bool Is(Object* object, Il2CppClass* cls)
+{ return object && il2cpp_object_get_class(object) == cls; }
+
+template <typename T> T Read(const void* object, std::size_t offset)
+{
+  T value{};
+  if (object)
+    std::memcpy(&value, static_cast<const char*>(object) + offset, sizeof(value));
+  return value;
+}
+
+// Inspect storage without invoking List getters/enumerators. Unknown layouts fail closed.
+inline Il2CppArraySize* List(Object* list, Il2CppClass* element, int limit, int& count)
+{
+  count = -1;
+  if (!list)
+    return nullptr;
+  auto* cls     = il2cpp_object_get_class(list);
+  auto* size    = il2cpp_class_get_field_from_name(cls, "_size");
+  auto* storage = il2cpp_class_get_field_from_name(cls, "_items");
+  if (!size || !storage || !size->type || size->type->type != IL2CPP_TYPE_I4 || !storage->type
+      || storage->type->type != IL2CPP_TYPE_SZARRAY || size->type->byref || storage->type->byref
+      || (il2cpp_field_get_flags(size) & FIELD_ATTRIBUTE_STATIC)
+      || (il2cpp_field_get_flags(storage) & FIELD_ATTRIBUTE_STATIC))
+    return nullptr;
+  Il2CppArray* items{};
+  il2cpp_field_get_value(list, size, &count);
+  il2cpp_field_get_value(list, storage, &items);
+  if (count < 0 || count > limit || !items || il2cpp_array_length(items) < static_cast<unsigned>(count)
+      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Object*>(items))) != element)
+    return nullptr;
+  return reinterpret_cast<Il2CppArraySize*>(items);
+}
+
+inline QueueState Snapshot(Object* queue)
+{
+  QueueState s;
+  if (!Is(queue, queueClass))
+    return s;
+  auto* items = List(Read<Object*>(queue, 0x28), actionClass, 128, s.count);
+  if (!items)
+    return {};
+  s.player_fleet_id        = Read<Id>(queue, 0x30);
+  s.is_engaging            = Read<bool>(queue, 0x10);
+  s.last_engaged_target_id = Read<Id>(queue, 0x18);
+  s.pending_target_id      = Read<Id>(queue, 0x20);
+  s.captured_target_count  = std::min(s.count, static_cast<int>(s.target_ids.size()));
+  s.targets_truncated      = s.count > s.captured_target_count;
+  for (int i = 0; i < s.captured_target_count; ++i) {
+    auto* action = static_cast<Object*>(items->vector[i]);
+    if (!Is(action, actionClass))
+      return {};
+    s.target_ids[i] = Read<Id>(action, 0x10);
+    if (!s.target_ids[i])
+      return {};
+  }
+  s.head_target_id = s.count ? s.target_ids[0] : 0;
+  s.present        = s.player_fleet_id != 0;
+  return s;
+}
+
+inline Object* FindQueue(Object* manager, Id fleet, Id head = 0)
+{
+  auto* array = Read<Il2CppArray*>(manager, 0x48);
+  if (!array || il2cpp_array_length(array) > 64
+      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Object*>(array))) != queueClass)
+    return nullptr;
+  auto* items = reinterpret_cast<Il2CppArraySize*>(array);
+  for (unsigned i = 0; i < items->max_length; ++i) {
+    auto*      queue = static_cast<Object*>(items->vector[i]);
+    const auto s     = Snapshot(queue);
+    if (s.present && (head ? s.head_target_id == head : s.player_fleet_id == fleet))
+      return queue;
+  }
+  return nullptr;
+}
+
+inline bool Field(Il2CppClass* cls, const char* name, std::ptrdiff_t offset, Il2CppTypeEnum type)
+{
+  auto*      f     = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
+  const bool valid = f && f->offset == offset && f->type && !f->type->byref
+                     && !(il2cpp_field_get_flags(f) & FIELD_ATTRIBUTE_STATIC) && f->type->type == type;
+  if (!valid)
+    spdlog::warn("[ThinQueueProtection] {}.{}: expected instance field offset=0x{:X} type={}; "
+                 "actual offset={} type={} static={} byref={}",
+                 cls ? cls->name : "<missing class>", name, offset, static_cast<int>(type), f ? f->offset : -1,
+                 f && f->type ? static_cast<int>(f->type->type) : -1,
+                 f && f->type && bool(il2cpp_field_get_flags(f) & FIELD_ATTRIBUTE_STATIC),
+                 f && f->type && bool(f->type->byref));
+  return valid;
+}
+
+template <typename T> bool Getter(T& out, Il2CppClass* cls, const char* name, const char* result)
+{
+  const auto* method = il2cpp::contract::Resolve(cls, name, false, result, {});
+  out = method && !method->has_full_generic_sharing_signature ? reinterpret_cast<T>(il2cpp::contract::Pointer(method))
+                                                              : nullptr;
+  if (method && method->return_type->type == IL2CPP_TYPE_VALUETYPE) {
+    auto*       type       = il2cpp_class_from_type(method->return_type);
+    const auto* underlying = type && il2cpp_class_is_enum(type) ? il2cpp_class_enum_basetype(type) : nullptr;
+    if (!underlying || underlying->type != IL2CPP_TYPE_I4)
+      out = nullptr;
+  }
+  if (!out)
+    spdlog::warn("[ThinQueueProtection] {}.{}: expected instance {}(); {}", cls ? cls->name : "<missing class>", name,
+                 result,
+                 !method                                      ? "method unavailable"
+                 : method->has_full_generic_sharing_signature ? "unsupported generic sharing"
+                 : !method->methodPointer                     ? "native pointer unavailable"
+                                                              : "expected Int32 enum result");
+  return out != nullptr;
+}
+
+inline void* plan{};
+inline void* stall{};
+inline void* disposed{};
+inline bool  ResolveBindings()
+{
+  auto* manager = il2cpp::Class<"Assembly-CSharp", "Prime.ActionQueue", "ActionQueueManager">::Raw();
+  queueClass    = il2cpp::Class<"Assembly-CSharp", "Prime.ActionQueue", "ActionQueueInstance">::Raw();
+  actionClass   = il2cpp::Class<"Assembly-CSharp", "Prime.ActionQueue", "QueueableAction">::Raw();
+  playerClass   = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetPlayerData">::Raw();
+  deployedClass =
+      il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetDeployedData">::Raw();
+  using il2cpp::contract::Pointer;
+  using il2cpp::contract::Resolve;
+  const auto* plan_info  = Resolve(manager, "DoPlanPathAndEngageTarget", false, "System.Boolean",
+                                   {"Digit.PrimeServer.Models.FleetPlayerData"});
+  plan                   = Pointer(plan_info);
+  const auto* stall_info = Resolve(manager, "HandleStall", false, "System.Void",
+                                   {"Prime.ActionQueue.ActionQueueInstance", "Digit.PrimeServer.Models.FleetPlayerData",
+                                    "Digit.PrimeServer.Models.FleetDeployedData"});
+  stall                  = Pointer(stall_info);
+  const auto* disposed_info = Resolve(manager, "OnFleetsDisposedEventHandler", false, "System.Void",
+                                      {"System.Collections.Generic.List<Digit.PrimeServer.Models.FleetDeployedData>"});
+  disposed                  = Pointer(disposed_info);
+  const auto* engage = Resolve(manager, "TryPlanPathAndEngageTarget", false, "Digit.Prime.Combat.EngageResult",
+                               {"Digit.PrimeServer.Models.FleetPlayerData", "Prime.ActionQueue.ActionQueueInstance"});
+  tryEngage          = reinterpret_cast<decltype(tryEngage)>(Pointer(engage));
+  const auto* process_info = Resolve(manager, "ProcessQueue", false, "System.Void", {"System.Int64", "System.Boolean"});
+  processTarget            = reinterpret_cast<decltype(processTarget)>(Pointer(process_info));
+  auto*       result       = engage ? il2cpp_class_from_type(engage->return_type) : nullptr;
+  const auto* underlying   = result && il2cpp_class_is_enum(result) ? il2cpp_class_enum_basetype(result) : nullptr;
+  const bool  valid =
+      manager && queueClass && actionClass && playerClass && deployedClass && plan && stall && disposed && tryEngage
+      && processTarget && underlying && underlying->type == IL2CPP_TYPE_I4
+      && !plan_info->has_full_generic_sharing_signature && !stall_info->has_full_generic_sharing_signature
+      && !disposed_info->has_full_generic_sharing_signature && !engage->has_full_generic_sharing_signature
+      && !process_info->has_full_generic_sharing_signature && plan != stall && plan != disposed && stall != disposed
+      && Field(manager, "_battleQueue", 0x48, IL2CPP_TYPE_SZARRAY)
+      && Field(queueClass, "IsEngaging", 0x10, IL2CPP_TYPE_BOOLEAN)
+      && Field(queueClass, "LastEngagedTargetId", 0x18, IL2CPP_TYPE_I8)
+      && Field(queueClass, "PendingEngageTargetId", 0x20, IL2CPP_TYPE_I8)
+      && Field(queueClass, "_actionQueue", 0x28, IL2CPP_TYPE_GENERICINST)
+      && Field(queueClass, "<PlayerFleetId>k__BackingField", 0x30, IL2CPP_TYPE_I8)
+      && Field(actionClass, "<FleetId>k__BackingField", 0x10, IL2CPP_TYPE_I8)
+      && Getter(playerId, playerClass, "get_Id", "System.Int64")
+      && Getter(playerState, playerClass, "get_CurrentState", "Digit.PrimeServer.Models.FleetState")
+      && Getter(deployedId, deployedClass, "get_ID", "System.Int64")
+      && Getter(deployedState, deployedClass, "get_CurrentState", "Digit.PrimeServer.Models.DeployedFleetState")
+      && Getter(removalReason, deployedClass, "get_RemovalReason", "Digit.PrimeServer.Models.FleetRemovalReason")
+      && Getter(destroyed, deployedClass, "get_IsDestroyed", "System.Boolean")
+      && Getter(battling, deployedClass, "get_CurrentlyBattling", "System.Boolean");
+  if (!valid) {
+    for (const auto& [type, name] : std::array{std::pair{manager, "Prime.ActionQueue.ActionQueueManager"},
+                                               std::pair{queueClass, "Prime.ActionQueue.ActionQueueInstance"},
+                                               std::pair{actionClass, "Prime.ActionQueue.QueueableAction"},
+                                               std::pair{playerClass, "Digit.PrimeServer.Models.FleetPlayerData"},
+                                               std::pair{deployedClass, "Digit.PrimeServer.Models.FleetDeployedData"}})
+      if (!type)
+        spdlog::warn("[ThinQueueProtection] unavailable: missing class {}", name);
+    const std::array methods{
+        std::pair{plan_info, "ActionQueueManager.DoPlanPathAndEngageTarget(FleetPlayerData) -> Boolean"},
+        std::pair{stall_info,
+                  "ActionQueueManager.HandleStall(ActionQueueInstance, FleetPlayerData, FleetDeployedData) -> Void"},
+        std::pair{disposed_info, "ActionQueueManager.OnFleetsDisposedEventHandler(List<FleetDeployedData>) -> Void"},
+        std::pair{
+            engage,
+            "ActionQueueManager.TryPlanPathAndEngageTarget(FleetPlayerData, ActionQueueInstance) -> EngageResult"},
+        std::pair{process_info, "ActionQueueManager.ProcessQueue(Int64, Boolean) -> Void"}};
+    for (const auto& [method, name] : methods)
+      if (!method || !method->methodPointer || method->has_full_generic_sharing_signature)
+        spdlog::warn("[ThinQueueProtection] unavailable: {}: {}", name,
+                     method && method->has_full_generic_sharing_signature ? "unsupported generic sharing"
+                                                                          : "instance method unavailable");
+    if (!underlying || underlying->type != IL2CPP_TYPE_I4)
+      spdlog::warn("[ThinQueueProtection] unavailable: EngageResult must be an Int32 enum");
+    // Only these three methods are detoured; the other two are native calls.
+    for (size_t i = 0; i < 3; ++i)
+      for (size_t j = 0; j < i; ++j)
+        if (methods[i].first && methods[j].first && methods[i].first->methodPointer
+            && methods[i].first->methodPointer == methods[j].first->methodPointer)
+          spdlog::warn("[ThinQueueProtection] unavailable: {} and {} share a native hook target", methods[i].second,
+                       methods[j].second);
+    return false;
+  }
+  return true;
+}
+
+} // namespace queue_bindings::thin
+namespace queue_bindings::address
+{
+using Object = Il2CppObject;
+using Id     = std::int64_t;
+inline Il2CppClass *managerClass{}, *queueClass{}, *actionClass{}, *playerClass{}, *deployedClass{};
+
+inline FieldInfo *queuesField{}, *fleetField{}, *actionsField{}, *targetField{}, *idField{}, *indexField{};
+
+inline bool Is(Object* object, Il2CppClass* cls)
+{ return object && il2cpp_object_get_class(object) == cls; }
+
+inline FieldInfo* Field(Il2CppClass* cls, const char* name, Il2CppTypeEnum type)
+{
+  auto* field = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
+
+  return field && field->type && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC) && field->offset >= sizeof(Object)
+                 && field->type->type == type
+             ? field
+             : nullptr;
+}
+template <typename T> T Read(Object* object, FieldInfo* field)
+{
+  T value{};
+  if (object && field)
+    il2cpp_field_get_value(object, field, &value);
+  return value;
+}
+inline Object* Reference(Object* object, const char* name)
+{
+  auto* cls   = object ? il2cpp_object_get_class(object) : nullptr;
+  auto* field = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
+  auto* type  = field && field->type ? il2cpp_class_from_type(field->type) : nullptr;
+  return type && !il2cpp_class_is_valuetype(type) && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)
+                 && field->offset >= sizeof(Object)
+             ? Read<Object*>(object, field)
+             : nullptr;
+}
+inline int Enum(Object* object, const char* name)
+{
+  auto* cls   = object ? il2cpp_object_get_class(object) : nullptr;
+  auto* field = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
+  auto* type  = field && field->type ? il2cpp_class_from_type(field->type) : nullptr;
+  auto* base  = type && il2cpp_class_is_enum(type) ? il2cpp_class_enum_basetype(type) : nullptr;
+  return base && base->type == IL2CPP_TYPE_I4 && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)
+                 && field->offset >= sizeof(Object)
+             ? Read<int>(object, field)
+             : -1;
+}
+inline int State(Object* object, const char* name)
+{
+  auto* cls       = object ? il2cpp_object_get_class(object) : nullptr;
+  auto* field     = cls ? il2cpp_class_get_field_from_name(cls, name) : nullptr;
+  auto* container = field && field->type ? il2cpp_class_from_type(field->type) : nullptr;
+  if (!container || !il2cpp_class_is_valuetype(container) || field->offset < sizeof(Object)
+      || (field->type->attrs & FIELD_ATTRIBUTE_STATIC))
+    return -1;
+  uint32_t  alignment{};
+  const int size   = il2cpp_class_value_size(container, &alignment);
+  auto*     inner  = il2cpp_class_get_field_from_name(container, "_currentState");
+  auto*     type   = inner && inner->type ? il2cpp_class_from_type(inner->type) : nullptr;
+  auto*     base   = type && il2cpp_class_is_enum(type) ? il2cpp_class_enum_basetype(type) : nullptr;
+  const int offset = inner ? inner->offset - static_cast<int>(sizeof(Object)) : -1;
+  if (!base || base->type != IL2CPP_TYPE_I4 || (inner->type->attrs & FIELD_ATTRIBUTE_STATIC) || offset < 0
+      || offset + sizeof(int) > size)
+    return -1;
+  int value{};
+  std::memcpy(&value, reinterpret_cast<const char*>(object) + field->offset + offset, sizeof(value));
+  return value;
+}
+inline queue_address_guard::Address Address(Object* object)
+{
+  auto* cls      = object ? il2cpp_object_get_class(object) : nullptr;
+  auto* galaxy   = Field(cls, "galaxy_", IL2CPP_TYPE_I8);
+  auto* system   = Field(cls, "system_", IL2CPP_TYPE_I8);
+  auto* planet   = Field(cls, "planet_", IL2CPP_TYPE_I8);
+  auto* instance = Field(cls, "instance_", IL2CPP_TYPE_I4);
+  if (!galaxy || !system || !planet || !instance)
+    return {};
+  queue_address_guard::Address value{true, Read<Id>(object, galaxy), Read<Id>(object, system), Read<Id>(object, planet),
+                                     Read<int>(object, instance)};
+  value.valid = value.galaxy >= 0 && value.system > 0 && value.planet >= 0 && value.instance >= 0;
+  return value;
+}
+
+// Existing queue snapshots use fixed Windows offsets. This guard also runs on macOS
+// and resolves metadata instead; unknown or incomplete storage retains native behavior.
+inline bool OwnsNonemptyQueue(Object* manager, Object* player, Id fleet)
+{
+  auto*     array = Read<Il2CppArray*>(manager, queuesField);
+  const int index = Read<int>(player, indexField);
+  if (!array || !fleet || index < 0 || il2cpp_array_length(array) > 64
+      || static_cast<unsigned>(index) >= il2cpp_array_length(array)
+      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Object*>(array))) != queueClass)
+    return false;
+  auto* queue = static_cast<Object*>(reinterpret_cast<Il2CppArraySize*>(array)->vector[index]);
+  if (!Is(queue, queueClass) || Read<Id>(queue, fleetField) != fleet)
+    return false;
+  auto* list    = Read<Object*>(queue, actionsField);
+  auto* cls     = list ? il2cpp_object_get_class(list) : nullptr;
+  auto* size    = Field(cls, "_size", IL2CPP_TYPE_I4);
+  auto* storage = Field(cls, "_items", IL2CPP_TYPE_SZARRAY);
+  if (!size || !storage)
+    return false;
+  const int count = Read<int>(list, size);
+  auto*     items = Read<Il2CppArray*>(list, storage);
+  if (count <= 0 || count > 128 || !items || il2cpp_array_length(items) < static_cast<unsigned>(count)
+      || il2cpp_class_get_element_class(il2cpp_object_get_class(reinterpret_cast<Object*>(items))) != actionClass)
+    return false;
+  for (int i = 0; i < count; ++i) {
+    auto* action = static_cast<Object*>(reinterpret_cast<Il2CppArraySize*>(items)->vector[i]);
+    if (!Is(action, actionClass) || !Read<Id>(action, targetField))
+      return false;
+  }
+  return true;
+}
+
+inline std::array<const MethodInfo*, 4> methods{};
+inline bool                             ResolveBindings()
+{
+  managerClass = il2cpp::Class<"Assembly-CSharp", "Prime.ActionQueue", "ActionQueueManager">::Raw();
+  queueClass   = il2cpp::Class<"Assembly-CSharp", "Prime.ActionQueue", "ActionQueueInstance">::Raw();
+  actionClass  = il2cpp::Class<"Assembly-CSharp", "Prime.ActionQueue", "QueueableAction">::Raw();
+  playerClass  = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetPlayerData">::Raw();
+  deployedClass =
+      il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "FleetDeployedData">::Raw();
+  auto* serviceClass =
+      il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "DeploymentService">::Raw();
+  queuesField  = Field(managerClass, "_battleQueue", IL2CPP_TYPE_SZARRAY);
+  fleetField   = Field(queueClass, "<PlayerFleetId>k__BackingField", IL2CPP_TYPE_I8);
+  actionsField = Field(queueClass, "_actionQueue", IL2CPP_TYPE_GENERICINST);
+  targetField  = Field(actionClass, "<FleetId>k__BackingField", IL2CPP_TYPE_I8);
+  idField      = Field(playerClass, "<ID>k__BackingField", IL2CPP_TYPE_I8);
+  indexField   = Field(playerClass, "<Index>k__BackingField", IL2CPP_TYPE_I4);
+  using il2cpp::contract::Pointer;
+  using il2cpp::contract::Resolve;
+  methods = {
+      Resolve(managerClass, "OnPlayerFleetStateChangedEventHandler", false, "System.Void",
+              {"System.Collections.Generic.List<Digit.PrimeServer.Models.FleetPlayerData>"}),
+      Resolve(managerClass, "DoesFleetQueueContainMismatchedAddressTargets", false, "System.Boolean",
+              {"Digit.PrimeServer.Models.FleetPlayerData"}),
+      Resolve(playerClass, "get_Address", false, "Digit.PrimeServer.Models.NodeAddress", {}),
+      Resolve(serviceClass, "GetDeployedFleet", false, "Digit.PrimeServer.Models.FleetDeployedData", {"System.Int64"})};
+  bool valid = managerClass && queueClass && actionClass && playerClass && deployedClass && serviceClass && queuesField
+               && fleetField && actionsField && targetField && idField && indexField;
+  for (unsigned i = 0; i < methods.size(); ++i) {
+    valid = valid && methods[i] && !methods[i]->has_full_generic_sharing_signature;
+    for (unsigned j = 0; j < i; ++j)
+      valid = valid && Pointer(methods[i]) != Pointer(methods[j]);
+  }
+  if (!valid) {
+    spdlog::warn("[QueueAddressGuard] native method/field contract unavailable; retaining native behavior");
+    return false;
+  }
+  return true;
+}
+
+inline bool IsLocalDeployment(Object* own, Id fleet)
+{
+  auto* cls         = own ? il2cpp_object_get_class(own) : nullptr;
+  auto* local       = Field(cls, "_localPlayerFleet", IL2CPP_TYPE_BOOLEAN);
+  auto* model       = Reference(own, "_deploymentFleet");
+  auto* model_class = model ? il2cpp_object_get_class(model) : nullptr;
+  auto* id          = Field(model_class, "fleetId_", IL2CPP_TYPE_I8);
+  if (!id)
+    id = Field(model_class, "<FleetId>k__BackingField", IL2CPP_TYPE_I8);
+  return local && Read<bool>(own, local) && id && Read<Id>(model, id) == fleet;
+}
+inline bool PlanningRecall(Object* own)
+{
+  auto* field = Field(own ? il2cpp_object_get_class(own) : nullptr, "<IsPlanningRecallCourse>k__BackingField",
+                      IL2CPP_TYPE_BOOLEAN);
+  return !field || Read<bool>(own, field);
+}
+
+} // namespace queue_bindings::address
diff --git a/mods/src/prime/EntityGroup.h b/mods/src/prime/server.h
similarity index 57%
rename from mods/src/prime/EntityGroup.h
rename to mods/src/prime/server.h
index 8f89f437d..a2b7bd64d 100644
--- a/mods/src/prime/EntityGroup.h
+++ b/mods/src/prime/server.h
@@ -1,5 +1,8 @@
 #pragma once
 
+// The game server (Digit.PrimeServer): its sessions, the entity groups and realtime messages it sends, and the
+// server models and services the mod reads, such as battle results, hull specs, buffs and events.
+
 #include <il2cpp/il2cpp.h>
 
 #include <cstdint>
@@ -16,7 +19,8 @@ struct ByteString : il2cpp::Object {
 struct EntityGroup : il2cpp::Object {
   using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "EntityGroup">;
 
-  enum Type : int32_t {
+  // The payload type, which also says which protobuf message the group's bytes hold.
+  enum class Kind : int32_t {
     UserProfiles                             = 0,   // 0x00000000
     HullSpecs                                = 1,   // 0x00000001
     ResourceSpecs                            = 2,   // 0x00000002
@@ -267,8 +271,312 @@ struct EntityGroup : il2cpp::Object {
     ResearchConfig       = 91100, // 0x000163DC
   };
 
-  Type Type_()
-  { return Get<"Type", Type>(); }
+  Kind Type()
+  { return Get<"Type", Kind>(); }
+  ByteString* Group()
+  { return Get<"Group", ByteString*>(); }
+};
+
+struct ServiceResponse : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "ServiceResponse">;
+
+  // Google.Protobuf.Collections.RepeatedField<EntityGroup>; List resolves Count/get_Item on it.
+  il2cpp::List<EntityGroup*>* EntityGroups()
+  { return Get<"EntityGroups", il2cpp::List<EntityGroup*>*>(); }
+};
+
+// The platform service's responses (store offers among them), Digit.Platform.Models. They pass through the same
+// model registry code as game server responses, but their entity groups have a type enum of their own.
+struct PlatformEntityGroup : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.Platform.Models", "EntityGroup">;
+
+  enum class Kind : int32_t {
+    StaticTranslations             = 0,  // 0x00000000
+    DynamicTranslations            = 1,  // 0x00000001
+    StoreOffers                    = 2,  // 0x00000002
+    OrderVirtualGood               = 3,  // 0x00000003
+    Json                           = 4,  // 0x00000004
+    TournamentBundles              = 5,  // 0x00000005
+    EventRanking                   = 6,  // 0x00000006
+    EventsModel                    = 7,  // 0x00000007
+    LeaderboardRanking             = 8,  // 0x00000008
+    LeaderboardsModel              = 9,  // 0x00000009
+    EventNotification              = 10, // 0x0000000A
+    PlayerStats                    = 11, // 0x0000000B
+    GameNews                       = 12, // 0x0000000C
+    FileSignedUrls                 = 13, // 0x0000000D
+    GameInfo                       = 14, // 0x0000000E
+    PlayerProfiles                 = 15, // 0x0000000F
+    PlayerlifecycleNotification    = 16, // 0x00000010
+    MinigamesList                  = 17, // 0x00000011
+    GameNewsVideo                  = 18, // 0x00000012
+    PromoCodeRedeem                = 19, // 0x00000013
+    StoreGroups                    = 20, // 0x00000014
+    AllianceGameState              = 21, // 0x00000015
+    AllianceGameChangeNotification = 22, // 0x00000016
+    ApmFiltersStatus               = 23, // 0x00000017
+    ApmFiltersUpdated              = 24, // 0x00000018
+    ListReferralConnections        = 25, // 0x00000019
+    RewardRedeem                   = 26, // 0x0000001A
+    LoginStreakRecalculate         = 27, // 0x0000001B
+    OrdersVirtualGood              = 28, // 0x0000001C
+  };
+
+  Kind Type()
+  { return Get<"Type", Kind>(); }
   ByteString* Group()
   { return Get<"Group", ByteString*>(); }
 };
+
+struct PlatformServiceResponse : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.Platform.Models", "ServiceResponse">;
+
+  il2cpp::List<PlatformEntityGroup*>* EntityGroups()
+  { return Get<"EntityGroups", il2cpp::List<PlatformEntityGroup*>*>(); }
+};
+
+// Hands each server response's entity groups to the client's models.
+using GameServerModelRegistry =
+    il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Core", "GameServerModelRegistry">;
+// The client's session with the game server.
+using GameServer = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Core", "GameServer">;
+
+// Realtime (Centrifugo) messages that change an entity slot.
+using SlotAssignRtcParser =
+    il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Parsers", "SlotAssignRtcParser">;
+using SlotClearRtcParser =
+    il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Parsers", "SlotClearRtcParser">;
+
+// Digit.Networking.RTC.CentrifugoInfo, a value type passed by value: a hook must keep it by value so the arguments
+// after it keep their ABI positions.
+struct CentrifugoInfo {
+  Il2CppString* Channel;
+  int32_t       Offset;
+};
+static_assert(sizeof(CentrifugoInfo) == 16);
+
+struct RealtimeDataPayload : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.Networking.RTC", "RealtimeDataPayload">;
+
+  // The DataType enum as a number in a string: "0" is JSON.
+  Il2CppString* DataType()
+  { return Get<"DataType", Il2CppString*>(); }
+  Il2CppString* Target()
+  { return Get<"Target", Il2CppString*>(); }
+  Il2CppString* Data()
+  { return Get<"Data", Il2CppString*>(); }
+};
+
+enum class HullType : int32_t {
+  Any          = -1,
+  Destroyer    = 0,
+  Survey       = 1,
+  Explorer     = 2,
+  Battleship   = 3,
+  Defense      = 4,
+  ArmadaTarget = 5,
+};
+
+struct IdRefs : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "IdRefs">;
+
+  Il2CppString* locaStringId()
+  { return Field<"_locaStringId", Il2CppString*>(); }
+  int64_t locaId()
+  { return Field<"locaId_", int64_t>(); }
+};
+
+struct HullSpec : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "HullSpec">;
+
+  int64_t Id()
+  { return Field<"id_", int64_t>(); }
+  // The internal key, such as "Hull_L30_Destroyer_Klingon_LIVE".
+  Il2CppString* name()
+  { return Field<"name_", Il2CppString*>(); }
+  HullType Type()
+  { return Get<"Type", HullType>(); }
+  IdRefs* idRefs()
+  { return Field<"idRefs_", IdRefs*>(); }
+};
+
+// IShipModel, read on each ship's runtime class.
+struct ShipModel : il2cpp::Object {
+  HullSpec* Hull()
+  { return Get<"Hull", HullSpec*>(); }
+  float HullDamage()
+  { return Get<"HullDamage", float>(); }
+};
+
+struct FleetService : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "FleetService">;
+
+  ShipModel* GetShip(int64_t ship_id)
+  { return Call<"GetShip", ShipModel*>(ship_id); }
+};
+
+struct SpecService : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "SpecService">;
+
+  HullSpec* GetHull(int64_t hullId)
+  { return Call<"GetHull", HullSpec*>(hullId); }
+};
+
+struct UserProfile : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "UserProfile">;
+
+  // NPC and marauder profiles have no name; the game names them by this localization id.
+  int64_t locaId()
+  { return Field<"_locaId", int64_t>(); }
+  Il2CppString* name()
+  { return Field<"name_", Il2CppString*>(); }
+  Il2CppString* UserId()
+  { return Get<"UserId", Il2CppString*>(); }
+  int32_t Level()
+  { return Get<"Level", int32_t>(); }
+};
+
+enum class BattleType : int32_t {
+  Fleet                       = 0,
+  Base                        = 1,
+  PassiveMarauder             = 2,
+  NpcInstantiated             = 3,
+  DockingPoint                = 4,
+  ActiveMarauder_MarauderInit = 5,
+  ActiveMarauder_PlayerInit   = 6,
+  ArmadaBase                  = 7,
+  ArmadaMarauder              = 8,
+  PveDockingPoint             = 9,
+  ArmadaAsb                   = 10,
+  ArmadaMta                   = 11,
+  Hazard                      = 12,
+  PveCuttingBeam              = 13,
+  PvpCuttingBeam              = 14,
+  PveChainShot                = 15,
+  PvpChainShot                = 16,
+};
+
+// What a battle toast's Data is.
+struct BattleResultHeader : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "BattleResultHeader">;
+
+  // The profiles are read untyped and treated as UserProfile, as the game does.
+  UserProfile* PlayerUserProfile()
+  { return static_cast<UserProfile*>(Get<"PlayerUserProfile", Il2CppObject*>()); }
+  UserProfile* EnemyUserProfile()
+  { return static_cast<UserProfile*>(Get<"EnemyUserProfile", Il2CppObject*>()); }
+  SpecService* specService()
+  { return static_cast<SpecService*>(Field<"_specService", Il2CppObject*>()); }
+  BattleType BattleType()
+  { return Get<"BattleType", ::BattleType>(); }
+  int64_t PlayerShipHullId()
+  { return Get<"PlayerShipHullId", int64_t>(); }
+  int64_t EnemyShipHullId()
+  { return Get<"EnemyShipHullId", int64_t>(); }
+};
+
+// What an ArmadaCreated toast's Data is. These classes are read on their runtime classes: the toast payload types
+// have moved between client builds, and the fields below are all the mod needs.
+struct ArmadaCreatedData : il2cpp::Object {
+  struct Profile : il2cpp::Object {
+    Il2CppString* name()
+    { return Field<"name_", Il2CppString*>(); }
+    int64_t locaId()
+    { return Field<"_locaId", int64_t>(); }
+  };
+
+  struct Attack : il2cpp::Object {
+    Profile* Owner()
+    { return Field<"<Owner>k__BackingField", Profile*>(); }
+    Profile* TargetUserProfile()
+    { return Field<"<TargetUserProfile>k__BackingField", Profile*>(); }
+    int32_t TargetLevel()
+    { return Field<"<TargetLevel>k__BackingField", int32_t>(); }
+  };
+
+  struct AllianceProfile : il2cpp::Object {
+    Il2CppString* tag()
+    { return Field<"tag_", Il2CppString*>(); }
+  };
+
+  Attack* ArmadaAttack()
+  { return Field<"ArmadaAttack", Attack*>(); }
+  AllianceProfile* Alliance()
+  { return Field<"Alliance", AllianceProfile*>(); }
+};
+
+// Digit.PrimePlatform.Models.EventCategories, a struct around one int32. The binding layer checks the kind, so it
+// is read as the struct, not as an int.
+struct EventCategories {
+  int32_t value;
+};
+
+// What an event toast's Data is.
+struct EventModel : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimePlatform.Models", "EventModel">;
+
+  int32_t category()
+  { return Field<"category_", EventCategories>().value; }
+};
+
+struct ResourceSpec : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "ResourceSpec">;
+
+  // Such as "Resource_FactionPoint_Federation".
+  Il2CppString* resourceId()
+  { return Field<"resourceId_", Il2CppString*>(); }
+};
+
+struct ForbiddenTech : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "ForbiddenTech">;
+
+  int64_t Id()
+  { return Get<"Id", int64_t>(); }
+};
+
+struct ForbiddenTechSlotParams : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "ForbiddenTechSlotParams">;
+
+  // The ship the tech is equipped on, whether or not it has a dock.
+  int64_t OwnerId()
+  { return Get<"OwnerId", int64_t>(); }
+};
+
+struct EntitySlot : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "EntitySlot">;
+
+  ForbiddenTechSlotParams* forbiddenTechSlotParams()
+  { return Get<"ForbiddenTechSlotParams", ForbiddenTechSlotParams*>(); }
+};
+
+struct InventoryItem : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "InventoryItem">;
+
+  ResourceSpec* resourceSpec()
+  { return Field<"_resourceSpec", ResourceSpec*>(); }
+  ForbiddenTech* forbiddenTech()
+  { return Get<"ForbiddenTech", ForbiddenTech*>(); }
+};
+
+// The context of a cargo bar.
+using CargoProgressData =
+    il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Models", "CargoProgressData">;
+
+// Works out which buffs apply. The hooks only pass the buff types through.
+using BuffService = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "BuffService">;
+
+struct IBuffData : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit", "IBuffData">;
+};
+
+struct IBuffComparer : il2cpp::Object {
+  using Class = il2cpp::Class<"Digit.Client.PrimeLib.Runtime", "Digit.PrimeServer.Services", "IBuffComparer">;
+};
+
+// Digit.PrimeServer.Models.ClientModifierType: which stat a buff modifies. The mod passes it through unread.
+enum class ClientModifierType : int32_t {};
+
+// Digit.PrimeServer.Models.BuffCondition; only the value the mod tests is named.
+enum class BuffCondition : int32_t {
+  CondSelfAtStation = 114,
+};
diff --git a/mods/src/prime/ui.h b/mods/src/prime/ui.h
new file mode 100644
index 000000000..f80fa73ab
--- /dev/null
+++ b/mods/src/prime/ui.h
@@ -0,0 +1,538 @@
+#pragma once
+
+// The game's UI framework (Digit.Client.UI): widgets, view controllers, canvases, buttons, lists, localization,
+// shortcuts, message boxes and toasts.
+
+#include <il2cpp/il2cpp.h>
+#include <il2cpp/method_contract.h>
+#include <unity/input.h>
+#include <unity/ui.h>
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+
+// Unity singletons expose a static Instance on their MonoSingleton`1<T> base.
+template <typename T> struct MonoSingleton : il2cpp::Object {
+  static T* Instance()
+  { return T::Class::template Get<"Instance", T*>(); }
+  // The singleton s_instance already holds, or null. Instance can search the scene or create a replacement.
+  static T* Existing()
+  { return T::Class::template Field<"s_instance", T*>(); }
+};
+
+// The non-generic MonoSingleton base; its static PrepareAllForReload runs before the game reloads.
+using MonoSingletonBase = il2cpp::Class<"Assembly-CSharp", "", "MonoSingleton">;
+
+// Digit.Client.UI.Widget`1. Members resolve on each widget's runtime class.
+template <typename T> struct Widget : il2cpp::Object {
+  T* Context()
+  { return Get<"Context", T*>(); }
+  bool enabled()
+  { return Get<"enabled", bool>(); }
+  bool isActiveAndEnabled()
+  { return Get<"isActiveAndEnabled", bool>(); }
+  bool IsActive()
+  { return Call<"IsActive", bool>(); }
+};
+
+enum class VisibilityState : int32_t {
+  Unknown = 0,
+  Show    = 1,
+  Hide    = 2,
+  Hidden  = 3,
+  Visible = 4,
+};
+
+struct VisibilityController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "VisibilityController">;
+
+  // bool selects Show(bool)/Hide(bool) over the int entry-point overloads.
+  void Show(bool instant = false)
+  { Call<"Show">(instant); }
+  void Hide(bool instant = false)
+  { Call<"Hide">(instant); }
+
+  VisibilityState state()
+  { return Field<"_state", VisibilityState>(); }
+  VisibilityState State()
+  { return Get<"VisibilityState", VisibilityState>(); }
+
+  // Shown or on its way in.
+  bool IsShown()
+  {
+    const auto current = state();
+    return current == VisibilityState::Visible || current == VisibilityState::Show;
+  }
+};
+
+struct CanvasController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "CanvasController">;
+
+  bool Visible()
+  { return Get<"Visible", bool>(); }
+  // The bound data context, of the class the canvas's view expects.
+  il2cpp::Object* Context()
+  { return Get<"Context", il2cpp::Object*>(); }
+  Il2CppString* name()
+  { return Get<"name", Il2CppString*>(); }
+  unity::Transform* transform()
+  { return Get<"transform", unity::Transform*>(); }
+
+  // The canvas a component is drawn on. Passing System.Type selects GetComponentInParent(Type) over the generic
+  // overload.
+  static CanvasController* Of(il2cpp::Object* component)
+  { return component ? component->Call<"GetComponentInParent", CanvasController*>(Class::TypeObject()) : nullptr; }
+
+  // Whether `component` is on a canvas that is currently visible.
+  static bool Shows(il2cpp::Object* component)
+  {
+    auto* canvas = Of(component);
+    return canvas && canvas->Visible();
+  }
+};
+
+// Digit.Client.UI.TextLocalizer: the label component that renders localized, parameterized text.
+struct TextLocalizer : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "TextLocalizer">;
+
+  // Declared on GraphicLocalizer<,>.
+  Il2CppString* identifier()
+  { return Field<"m_identifier", Il2CppString*>(); }
+  // These localizers render on every UI update, so the identifier is compared without converting it.
+  bool IdentifierIs(std::string_view name)
+  { return il2cpp::Equals(identifier(), name); }
+  // The backing field, not the SignificantDecimals property.
+  void SetSignificantDecimals(int32_t value)
+  { SetField<"m_significantDecimals">(value); }
+  bool textOverride()
+  { return Field<"_textOverride", bool>(); }
+  // Declared on GraphicLocalizer<,>: the rendered graphic, resolved lazily even on inactive labels.
+  il2cpp::Object* Target()
+  { return Get<"Target", il2cpp::Object*>(); }
+
+  Il2CppString* CurrentText()
+  { return Call<"CurrentText", Il2CppString*>(); }
+  void ClearTextOverride()
+  { Call<"ClearTextOverride">(); }
+  void OverrideLocalizedText(Il2CppString* text)
+  { Call<"OverrideLocalizedText">(text); }
+};
+
+struct ColourTextLocalizer : TextLocalizer {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "ColourTextLocalizer">;
+};
+
+// Identifier and category that the localizer turns into display text. Construct with
+// il2cpp::New<LocaleTextContext>(identifier, category).
+struct LocaleTextContext : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "LocaleTextContext">;
+
+  // Fills the {N} slots of the identifier itself, e.g. "ship_name_{0}".
+  void ApplyIdentifierParameters(il2cpp::Array<Il2CppObject*>* parameters)
+  { Call<"ApplyIdentifierParameters">(parameters); }
+};
+
+struct LocaleUtilities {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Localization", "LocaleUtilities">;
+
+  static Il2CppString* Localize(LocaleTextContext* context, bool localizeTextParams = false,
+                                bool invariantCulture = false)
+  { return Class::Call<"Localize", Il2CppString*>(context, localizeTextParams, invariantCulture); }
+
+  // `identifier` (such as "ship_name_{0}") in `category`, with its one slot filled by `parameter`. Empty when the
+  // text cannot be built. An unknown identifier localizes to itself.
+  static std::string Localize(std::string_view identifier, std::string_view category, Il2CppObject* parameter)
+  {
+    auto* parameters = parameter ? il2cpp::Array<Il2CppObject*>::New(il2cpp::ObjectClass(), 1) : nullptr;
+    auto* context    = parameters
+                           ? il2cpp::New<LocaleTextContext>(il2cpp::NewString(identifier), il2cpp::NewString(category))
+                           : nullptr;
+    if (!context)
+      return {};
+    parameters->Set(0, parameter);
+    context->ApplyIdentifierParameters(parameters);
+    return il2cpp::ToUtf8(Localize(context, false, false));
+  }
+};
+
+struct Localizer {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Localization", "Localizer">;
+
+  // textCase is TextLocalizer.TextCase; 0 leaves the text as translated.
+  static Il2CppString* Localise(LocaleTextContext* context, bool forceCommas = false, int32_t textCase = 0)
+  { return Class::Call<"Localise", Il2CppString*>(context, forceCommas, textCase); }
+};
+
+struct LanguageManager : MonoSingleton<LanguageManager> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.Localization", "LanguageManager">;
+
+  bool Localize(Il2CppString*& translation, LocaleTextContext* context)
+  { return Call<"Localize", bool(Il2CppString*&, LocaleTextContext*)>(translation, context); }
+
+  static void ClearCache()
+  { Class::Call<"ClearCache">(); }
+};
+
+struct SemaphoreListenerBase : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "SemaphoreListenerBase">;
+};
+
+struct SemaphoreButtonListener : SemaphoreListenerBase {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "SemaphoreButtonListener">;
+
+  unity::Button* TheButton()
+  { return Field<"_button", unity::Button*>(); }
+  bool isActiveAndEnabled()
+  { return Get<"isActiveAndEnabled", bool>(); }
+
+  // Presses the listener's button, if it has one.
+  void Press()
+  {
+    if (auto* button = TheButton())
+      button->Press();
+  }
+};
+
+struct GenericButtonContext : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "GenericButtonContext">;
+
+  bool Interactable()
+  { return Get<"Interactable", bool>(); }
+  void SetInteractable(bool value)
+  { Set<"Interactable">(value); }
+};
+
+struct GenericButtonWidget : Widget<GenericButtonContext> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "GenericButtonWidget">;
+
+  SemaphoreButtonListener* SemaphoreListener()
+  { return Field<"_semaphoreButtonListener", SemaphoreButtonListener*>(); }
+  TextLocalizer* mainText()
+  { return Field<"_mainText", TextLocalizer*>(); }
+  bool Interactable()
+  { return Get<"Interactable", bool>(); }
+
+  // The Unity button behind the widget, or null.
+  unity::Button* TheButton()
+  {
+    auto* listener = SemaphoreListener();
+    return listener ? listener->TheButton() : nullptr;
+  }
+};
+
+struct ButtonAndContextWrapper : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "ButtonAndContextWrapper">;
+
+  GenericButtonWidget* Widget()
+  { return Field<"Widget", GenericButtonWidget*>(); }
+};
+
+struct InputFieldWidget : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "InputFieldWidget">;
+
+  void Focus()
+  { Call<"Focus">(); }
+  bool isActiveAndEnabled()
+  { return Get<"isActiveAndEnabled", bool>(); }
+};
+
+// Digit.Client.UI list hierarchy: BaseListContainer <- SelectableListBase <- SelectableList <- TabBar.
+// Data is a System.Collections.IList; elements are whatever the list was bound to.
+struct BaseListContainer : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "BaseListContainer">;
+
+  il2cpp::List<il2cpp::Object*>* data()
+  { return Field<"_data", il2cpp::List<il2cpp::Object*>*>(); }
+  int32_t Count()
+  { return Get<"Count", int32_t>(); }
+};
+
+struct SelectableList : BaseListContainer {
+  void Rebuild(il2cpp::Object* provider)
+  {
+    auto* data = Get<"Data", il2cpp::Object*>();
+    if (data)
+      Call<"ClearAndGenerateContents">(provider, data);
+  }
+
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "SelectableList">;
+
+  int32_t SelectedIndex()
+  { return Get<"SelectedIndex", int32_t>(); }
+
+  // Declared on SelectableListBase. The int overload is picked over RequestSelect(Component, bool).
+  void RequestSelect(int32_t index, bool simulated = false)
+  { Call<"RequestSelect">(index, simulated); }
+
+  il2cpp::Object* DataItem(int32_t index)
+  {
+    auto* list = Get<"Data", il2cpp::List<il2cpp::Object*>*>();
+    return list ? (*list)[index] : nullptr;
+  }
+};
+
+struct TabBar : SelectableList {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "TabBar">;
+};
+
+struct TabBarViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "TabBarViewController">;
+
+  TabBar* tabBar()
+  { return Field<"_tabBar", TabBar*>(); }
+};
+
+struct UIFrameManager : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "UIFrameManager">;
+
+  // The game clamps the width to the available space and the side frame's minimum. False when the call failed.
+  bool ResizeSideFrame(float width)
+  { return TryCall<"ResizeSideFrame", void(float)>(width); }
+};
+
+struct ScreenManager : MonoSingleton<ScreenManager> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "ScreenManager">;
+
+  // The canvas drawn on top; with visible_only, the top one that is shown.
+  static CanvasController* GetTopCanvas(bool visible_only)
+  { return Class::Call<"GetTopCanvas", CanvasController*>(visible_only); }
+
+  // The first live T on a visible registered canvas whose data context is a T::Context. Only the canvas that owns
+  // that context is searched: the top canvas and the scene root can belong to unrelated overlays.
+  template <typename T> static T* View()
+  {
+    struct Context {
+      using Class = typename T::Context;
+    };
+    auto*         manager = Existing();
+    auto*         screens = unity::Alive(manager) ? manager->screens() : nullptr;
+    const int32_t count   = screens ? screens->Count() : 0;
+    if (count < 0 || count > 256)
+      return nullptr;
+    for (int32_t index = 0; index < count; ++index) {
+      auto* canvas  = (*screens)[index];
+      auto* context = unity::Alive(canvas) ? canvas->Context() : nullptr;
+      if (!context || !context->Is<Context>() || !canvas->Visible())
+        continue;
+      auto* transform = canvas->transform();
+      auto* object    = transform ? transform->gameObject() : nullptr;
+      if (auto* view = object ? object->template GetComponentInChildren<T>() : nullptr; unity::Alive(view))
+        return view;
+    }
+    return nullptr;
+  }
+
+  // Every registered canvas, visible or not.
+  il2cpp::List<CanvasController*>* screens()
+  { return Field<"_screens", il2cpp::List<CanvasController*>*>(); }
+  unity::CanvasScaler* canvasRootScaler()
+  { return Field<"m_canvasRootScaler", unity::CanvasScaler*>(); }
+  UIFrameManager* frameManager()
+  { return Field<"_frameManager", UIFrameManager*>(); }
+};
+
+struct ShortcutsManager : MonoSingleton<ShortcutsManager> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.GameInput", "ShortcutsManager">;
+
+  bool ShowKeybindings()
+  { return Get<"ShowKeybindings", bool>(); }
+  void SetShowKeybindings(bool value)
+  { Set<"ShowKeybindings">(value); }
+  // Private static gate the native shortcut actions check (tutorial, modals, text input).
+  static bool CanUseShortcuts()
+  { return Class::Get<"CanUseShortcuts", bool>(); }
+
+  // Runs one of the On*Action(InputAction.CallbackContext) handlers, as the game's own shortcut for it would.
+  template <il2cpp::Name Action> void Run()
+  { Call<Action>(unity::InputActionCallbackContext{}); }
+};
+
+// The badge next to a button that shows the key of one of the game's input actions.
+struct ShortcutKeybindHint : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.GameInput", "ShortcutKeybindHint">;
+
+  unity::InputActionReference* inputAction()
+  { return Field<"_inputAction", unity::InputActionReference*>(); }
+  TextLocalizer* keyTextLocalizer()
+  { return Field<"_keyTextLocalizer", TextLocalizer*>(); }
+};
+
+using GameMessageBox = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "MessageBox">;
+
+// MessageBox.ButtonResult
+enum class MessageBoxResult : int32_t {
+  Confirm = 1,
+  Yes     = 3,
+};
+
+struct MessageBoxContext : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "MessageBoxContext">;
+
+  // Action<MessageBox.ButtonResult>
+  Il2CppDelegate* OnSelection()
+  { return Field<"OnSelection", Il2CppDelegate*>(); }
+};
+
+// Digit.Prime.HUD.ToastState: what a toast banner reports.
+enum class ToastState : int32_t {
+  Standard                          = 0,
+  FactionWarning                    = 1,
+  FactionLevelUp                    = 2,
+  FactionLevelDown                  = 3,
+  FactionDiscovered                 = 4,
+  IncomingAttack                    = 5,
+  IncomingAttackFaction             = 6,
+  FleetBattle                       = 7,
+  StationBattle                     = 8,
+  StationVictory                    = 9,
+  Victory                           = 10,
+  Defeat                            = 11,
+  StationDefeat                     = 12,
+  Tournament                        = 14,
+  ArmadaCreated                     = 15,
+  ArmadaCanceled                    = 16,
+  ArmadaIncomingAttack              = 17,
+  ArmadaBattleWon                   = 18,
+  ArmadaBattleLost                  = 19,
+  DiplomacyUpdated                  = 20,
+  JoinedTakeover                    = 21,
+  CompetitorJoinedTakeover          = 22,
+  AbandonedTerritory                = 23,
+  TakeoverVictory                   = 24,
+  TakeoverDefeat                    = 25,
+  TreasuryProgress                  = 26,
+  TreasuryFull                      = 27,
+  Achievement                       = 28,
+  AssaultVictory                    = 29,
+  AssaultDefeat                     = 30,
+  ChallengeComplete                 = 31,
+  ChallengeFailed                   = 32,
+  StrikeHit                         = 33,
+  StrikeDefeat                      = 34,
+  WarchestProgress                  = 35,
+  WarchestFull                      = 36,
+  PartialVictory                    = 37,
+  ArenaTimeLeft                     = 38,
+  ChainedEventScored                = 39,
+  FleetPresetApplied                = 40,
+  SurgeWarmUpEnded                  = 41,
+  SurgeHostileGroupDefeated         = 42,
+  SurgeTimeLeft                     = 43,
+  QueueForLeaseActivated            = 44,
+  QueueForLeaseExpired              = 45,
+  PermanentQueuePurchased           = 46,
+  OutpostStartedOrEnded             = 47,
+  CrossAllianceArmadaVictory        = 48,
+  CrossAllianceArmadaDefeat         = 49,
+  CrossAllianceArmadaPartialVictory = 50,
+  FactionWeeklyEventsProgress       = 51,
+  FactionWeeklyEventsComplete       = 52,
+  ArmadaPlayerBlocked               = 53,
+  ArmadaPlayerUnblocked             = 54,
+  DynamicCrisisUpdate               = 55,
+  DynamicCrisisFailed               = 56,
+  DynamicCrisisCompleted            = 57,
+  GalacticAnomalySystemEntered      = 58,
+};
+
+struct Toast : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "Toast">;
+
+  ToastState State()
+  { return Get<"State", ToastState>(); }
+  il2cpp::Array<Il2CppObject*>* TextParameters()
+  { return Get<"TextParameters", il2cpp::Array<Il2CppObject*>*>(); }
+  LocaleTextContext* TextLocaleTextContext()
+  { return static_cast<LocaleTextContext*>(Get<"TextLocaleTextContext", Il2CppObject*>()); }
+  // A different type per toast state: BattleResultHeader, EventModel, ArmadaCreatedData, ...
+  il2cpp::Object* Data()
+  { return Get<"Data", il2cpp::Object*>(); }
+};
+
+// Queues toast banners for display.
+struct ToastObserver : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.HUD", "ToastObserver">;
+};
+
+struct AnimatedRewardsScreenViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Missions.UI", "AnimatedRewardsScreenViewController">;
+
+  void GoBackToLastSection()
+  { Call<"GoBackToLastSection">(); }
+  bool IsActive()
+  { return Call<"IsActive", bool>(); }
+};
+
+// The -/+ stepper on upgrade and quantity screens.
+struct ElementSelectorViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.UI", "ElementSelectorViewController">;
+
+  // Through the internal call, so a drifted managed binding never hides the arrow-key shortcuts.
+  bool isActiveAndEnabled()
+  { return unity::ActiveAndEnabled(this); }
+
+  void PressDecrement()
+  {
+    if (auto* button = Field<"_decrementButton", unity::Button*>())
+      button->Press();
+  }
+  void PressIncrement()
+  {
+    if (auto* button = Field<"_incrementButton", unity::Button*>())
+      button->Press();
+  }
+};
+
+struct ArtifactHallDetailsViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ArtifactHall", "ArtifactHallDetailsViewController">;
+
+  // Through the internal call, so a drifted managed binding never hides the arrow-key shortcuts.
+  bool isActiveAndEnabled()
+  { return unity::ActiveAndEnabled(this); }
+
+  void PressLeftArrow()
+  {
+    if (auto* listener = Field<"_leftArrowButton", SemaphoreButtonListener*>())
+      listener->Press();
+  }
+  void PressRightArrow()
+  {
+    if (auto* listener = Field<"_rightArrowButton", SemaphoreButtonListener*>())
+      listener->Press();
+  }
+};
+
+// The cargo bar's "X of Y" label. Its fields are declared on LegacyProgressBar and Widget`1; lookups walk the
+// parents.
+struct LegacyComparableProgressBar : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Stats", "LegacyComparableProgressBar">;
+
+  TextLocalizer* currentValue_X_of_Y()
+  { return Field<"_currentValue_X_of_Y", TextLocalizer*>(); }
+  // IProgressData
+  il2cpp::Object* context()
+  { return Field<"m_context", il2cpp::Object*>(); }
+  bool snapToValue()
+  { return Field<"_snapToValue", bool>(); }
+  void SetSnapToValue(bool value)
+  { SetField<"_snapToValue">(value); }
+};
+
+struct MessageUtility : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Client.UI", "MessageUtility">;
+  static void* RevealConfirmationTarget()
+  {
+    const auto* method = il2cpp::contract::Resolve(Class::Raw(), "ShowFreeAbilityConfirmationPopup", true,
+                                                   "System.Void", {"System.Int64", "System.TimeSpan", "System.Action"});
+    return method && !method->has_full_generic_sharing_signature ? il2cpp::contract::Pointer(method) : nullptr;
+  }
+  static bool InvokeActivationAction(Il2CppDelegate* action)
+  {
+    if (!action || !action->method)
+      return false;
+    Il2CppException* exception = nullptr;
+    il2cpp_runtime_invoke(action->method, action->target, nullptr, &exception);
+    return !exception;
+  }
+};
diff --git a/mods/src/prime/viewers.h b/mods/src/prime/viewers.h
new file mode 100644
index 000000000..439d4e5cb
--- /dev/null
+++ b/mods/src/prime/viewers.h
@@ -0,0 +1,134 @@
+#pragma once
+
+// Object viewer cards shown for targets in space, and their scan/engage buttons.
+
+#include "prime/fleet.h"
+#include "prime/navigation.h"
+#include "prime/ui.h"
+
+#include <il2cpp/il2cpp.h>
+
+#include <cstdint>
+
+struct ParentObjectViewerViewController : il2cpp::Object {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "ParentObjectViewerViewController">;
+  bool IsShowing()
+  { return Get<"IsShowing", bool>(); }
+};
+
+struct ObjectViewerBaseWidget : Widget<NavigationInteractionUIContext> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "ObjectViewerBaseWidget">;
+
+  ParentObjectViewerViewController* Parent()
+  { return Get<"Parent", ParentObjectViewerViewController*>(); }
+  void HideAllViewers()
+  { Call<"HideAllViewers">(); }
+
+  VisibilityController* visibilityController()
+  { return Field<"_visibilityController", VisibilityController*>(); }
+};
+
+struct RewardsButtonWidget : Widget<BattleTargetData> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Combat", "RewardsButtonWidget">;
+
+  VisibilityController* rewardsController()
+  { return Field<"_rewardsController", VisibilityController*>(); }
+};
+
+struct ScanEngageButtonsWidget : Widget<BattleTargetData> {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Combat", "ScanEngageButtonsWidget">;
+
+  void OnArmadaButtonClicked()
+  { Call<"OnArmadaButtonClicked">(); }
+  void OnEngageButtonClicked()
+  { Call<"OnEngageButtonClicked">(); }
+  void OnScanButtonClicked()
+  { Call<"OnScanButtonClicked">(); }
+};
+
+struct PreScanTargetWidget : ObjectViewerBaseWidget {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.Combat", "PreScanTargetWidget">;
+
+  ScanEngageButtonsWidget* scanEngageButtonsWidget()
+  { return Field<"_scanEngageButtonsWidget", ScanEngageButtonsWidget*>(); }
+  RewardsButtonWidget* rewardsButtonWidget()
+  { return Field<"_rewardsButtonWidget", RewardsButtonWidget*>(); }
+  GenericButtonWidget* addToQueueButtonWidget()
+  { return Field<"_addToQueueButtonWidget", GenericButtonWidget*>(); }
+  GenericButtonWidget* armadaAttackButton()
+  { return Field<"_armadaAttackButton", GenericButtonWidget*>(); }
+};
+
+struct AllianceStarbaseObjectViewerWidget : ObjectViewerBaseWidget {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "AllianceStarbaseObjectViewerWidget">;
+};
+
+struct ArmadaObjectViewerWidget : ObjectViewerBaseWidget {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "ArmadaObjectViewerWidget">;
+
+  void ValidateThenJoinArmada()
+  { Call<"ValidateThenJoinArmada">(); }
+
+  GenericButtonContext* joinContext()
+  { return Field<"_joinContext", GenericButtonContext*>(); }
+};
+
+struct CelestialObjectViewerWidget : ObjectViewerBaseWidget {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "CelestialObjectViewerWidget">;
+};
+
+struct EmbassyObjectViewer : ObjectViewerBaseWidget {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "EmbassyObjectViewer">;
+};
+
+struct HousingObjectViewerWidget : ObjectViewerBaseWidget {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "HousingObjectViewerWidget">;
+};
+
+// MiningObjectViewerWidget.OccupiedState, a private nested enum.
+enum class OccupiedState : int32_t { NotOccupied = 0, LocalPlayerOccupied = 1, OtherPlayerOccupied = 2 };
+
+struct MiningObjectViewerWidget : ObjectViewerBaseWidget {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "MiningObjectViewerWidget">;
+
+  void MineClicked()
+  { Call<"MineClicked">(); }
+
+  ScanEngageButtonsWidget* scanEngageButtonsWidget()
+  { return Field<"_scanEngageButtonsWidget", ScanEngageButtonsWidget*>(); }
+};
+
+struct MissionsObjectViewerWidget : ObjectViewerBaseWidget {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "MissionsObjectViewerWidget">;
+};
+
+struct WaveDefenseObjectViewerWidget : ObjectViewerBaseWidget {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "WaveDefenseObjectViewerWidget">;
+
+  GenericButtonWidget* primaryButton()
+  { return Field<"_primaryButton", GenericButtonWidget*>(); }
+
+  void PressPrimaryButton()
+  {
+    auto* widget = primaryButton();
+    if (!widget || !widget->isActiveAndEnabled()) {
+      return;
+    }
+    auto* context  = widget->Context();
+    auto* listener = widget->SemaphoreListener();
+    if (context && context->Interactable() && listener) {
+      listener->Press();
+    }
+  }
+};
+
+struct StarNodeObjectViewerWidget : ObjectViewerBaseWidget {
+  using Class = il2cpp::Class<"Assembly-CSharp", "Digit.Prime.ObjectViewer", "StarNodeObjectViewerWidget">;
+
+  void OnViewButtonActivation()
+  { Call<"OnViewButtonActivation">(); }
+  void InitiateWarp()
+  { Call<"InitiateWarp">(); }
+  GenericButtonWidget* visitButton()
+  { return Field<"_visitButton", GenericButtonWidget*>(); }
+};
diff --git a/mods/src/prime_types.h b/mods/src/prime_types.h
deleted file mode 100644
index b2c790be1..000000000
--- a/mods/src/prime_types.h
+++ /dev/null
@@ -1,111 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-enum Faction
-{
-    None = -1,
-    Undefined = 0,
-    Federation = 1,
-    Klingon = 2,
-    Romulan = 3,
-};
-
-struct HullSpec;
-
-class SpecManager;
-using GetHull_t = HullSpec *(*)(SpecManager *_this, uint64_t, void *);
-
-#pragma pack(push, 1)
-struct SpecManagerVtbl
-{
-    char pad0[0x1C8];
-    GetHull_t GetHull;
-    void *TypeDefinition;
-};
-
-// static_assert(offsetof(SpecManagerVtbl, GetHull) == 0x1C8);
-
-class SpecManager
-{
-public:
-    SpecManagerVtbl vtbl;
-};
-// static_assert(offsetof(SpecManager, vtbl) == 0x0);
-#pragma pack(pop)
-
-
-enum BuffCondition
-{
-    Invalid = -1,
-    SelfExplorer = 0,
-    SelfInterceptor = 1,
-    SelfBattleship = 2,
-    SelfSurveyor = 3,
-    EnemyExplorer = 4,
-    EnemyInterceptor = 5,
-    EnemyBattleship = 6,
-    EnemySentinel = 8,
-    CondCargoFull = 9,
-    CondCargoEmpty = 10,
-    CondSelfMining = 12,
-    SelfOrSentinelAttacked = 14,
-    // TODO(alexander): Find a better name
-    EnemyStronger = 16,
-    CondEnemyHullFaction = 17,
-    CondEnemyHostile = 27,
-    CondEnemyPlayer = 28,
-    CondSelfHasMorale = 33,
-    CondSelfHasHullBreach = 34,
-    CondSelfIsBurning = 35,
-    CondEnemyHullBreach = 37,
-    CondEnemyBurning = 38,
-    CondModuleEnergy = 39,
-    CondModuleKinetic = 40,
-    CondHitEnemyWithEnergy = 41,
-    CondHitEnemyWithKinetic = 42,
-    CondHullHealthBelow = 43,
-    CondHullHealthBelowStartOfCombat = 44,
-    // I wonder what could be here...maybe some server only things? Who knows
-    CondSelfShipGrade = 102,
-    CondSelfHullFaction = 113,
-    CondSelfAtStation = 114,
-    SelfSentinel = 116,
-    CondEnemySentinel = 117, // TODO(alexander): What wait???? We have the before aswell, why is this a thing again??? see condition 8
-    CondResourceId = 118,
-    CondSelfModuleId = 119,
-    CondSelfShipgrade1 = 120,
-    CondSelfShipgrade2 = 121,
-    CondSelfShipgrade3 = 122,
-    CondSelfShipgrade4 = 123,
-    CondSelfIsFederation = 124, // Not sure why they haven't used CondSelfHullFaction for this...but hey whatever
-    CondSelfIsRomulan = 125,
-    CondSelfIsKlingon = 126,
-    CondSelfFranklin = 127,
-    CondSelfIsArmada = 129,
-    CondSelfIsNotArmada = 131,
-    CondTargetShipGrade1 = 132,
-    CondTargetShipGrade2 = 133,
-    CondTargetShipGrade3 = 134,
-    CondTargetShipGrade4 = 135,
-    CondSelfHullMudd = 150,
-    CondSelfHullBotanyBay = 151,
-    CondSelfHullDiscovery = 152,
-    CondSelfHullSarcophagus = 153,
-    CondSelfHullVidar = 154,
-    CondSelfHullDvor = 155,
-    CondSelfHullFranklin = 156,
-    CondSelfHullBlackJellyfish = 157,
-    CondSelfHullFranklin2 = 158,
-    CondSelfHullEnterprise = 159,
-    CondSelfHullEnterpriseA = 160,
-    CondSelfHullD4 = 161,
-    CondSelfHullHeghta = 162,
-    CondSelfHullAugur = 163,
-    CondSelfHullTribune = 164,
-    CondSelfHullSaladin = 165,
-    CondSelfHullCenturion = 166,
-    CondSelfHullBortas = 167,
-    CondSelfIsSynciate30 = 203,
-    CondSelfIsMantis = 207,
-};
\ No newline at end of file
diff --git a/mods/src/ship_name_match.h b/mods/src/ship_name_match.h
deleted file mode 100644
index c02ca65a9..000000000
--- a/mods/src/ship_name_match.h
+++ /dev/null
@@ -1,109 +0,0 @@
-#pragma once
-
-#include "str_utils.h"
-
-#include <il2cpp/il2cpp.h>
-
-#include <prime/FleetPlayerData.h>
-#include <prime/HullSpec.h>
-#include <prime/LocaleTextContext.h>
-
-#include <string>
-#include <string_view>
-#include <vector>
-
-namespace ShipNameMatch {
-
-inline std::string NormalizeKey(std::string_view raw)
-{
-  auto upper = AsciiStrToUpper(raw);
-
-  std::string cleaned;
-  cleaned.reserve(upper.size());
-  for (const char c : upper) {
-    if (c == '_' || c == '-') {
-      cleaned.push_back(' ');
-    } else if (c == '.' || c == '\'') {
-      continue; // drop, don't split: "U.S.S." -> "USS", not "U S S"
-    } else {
-      cleaned.push_back(c);
-    }
-  }
-
-  std::string collapsed;
-  collapsed.reserve(cleaned.size());
-  bool prev_space = false;
-  for (const char c : cleaned) {
-    const bool is_space = (c == ' ');
-    if (is_space && prev_space) continue;
-    collapsed.push_back(c);
-    prev_space = is_space;
-  }
-
-  auto trimmed = StripAsciiWhitespace(collapsed);
-  return std::string(StripPrefix(trimmed, "USS "));
-}
-
-inline std::vector<std::string> SplitWords(std::string_view key)
-{
-  std::vector<std::string> words;
-  std::string              current;
-  for (const char c : key) {
-    if (c == ' ') {
-      if (!current.empty()) {
-        words.push_back(std::move(current));
-        current.clear();
-      }
-    } else {
-      current.push_back(c);
-    }
-  }
-  if (!current.empty()) words.push_back(std::move(current));
-  return words;
-}
-
-// True if `pinned` is a trailing (suffix) subsequence of `candidate`'s words,
-// e.g. pinned=["ATHENA"] matches candidate=["ACADEMY","ATHENA"].
-inline bool EndsWithWords(const std::vector<std::string>& candidate, const std::vector<std::string>& pinned)
-{
-  if (pinned.empty() || candidate.size() < pinned.size()) return false;
-  const size_t offset = candidate.size() - pinned.size();
-  for (size_t i = 0; i < pinned.size(); ++i) {
-    if (candidate[offset + i] != pinned[i]) return false;
-  }
-  return true;
-}
-
-inline std::string LocalizedShipName(int64_t loca_id)
-{
-  if (loca_id <= 0) return {};
-
-  auto* id_str  = il2cpp_string_new(("ship_name_" + std::to_string(loca_id)).c_str());
-  auto* cat_str = il2cpp_string_new("ships");
-  auto* ctx     = il2cpp::New<LocaleTextContext>(id_str, cat_str);
-  if (!ctx) return {};
-
-  if (const auto* str = Localizer::Localise(ctx); str != nullptr) {
-    return to_string(str);
-  }
-  return {};
-}
-
-inline std::string GameDisplayName(FleetPlayerData* ship)
-{
-  return ship && ship->Hull() ? LocalizedShipName(ship->GetLocaId()) : std::string{};
-}
-
-inline std::vector<std::string> DisplayWords(FleetPlayerData* ship)
-{
-  if (!ship) return {};
-
-  return SplitWords(NormalizeKey(GameDisplayName(ship)));
-}
-
-inline bool MatchesDisplay(const std::vector<std::string>& display_words, const std::vector<std::string>& pinned_words)
-{
-  return EndsWithWords(display_words, pinned_words);
-}
-
-} // namespace ShipNameMatch
diff --git a/mods/src/str_utils.h b/mods/src/str_utils.h
index 774e29d86..615f1924b 100644
--- a/mods/src/str_utils.h
+++ b/mods/src/str_utils.h
@@ -1,177 +1,144 @@
 #pragma once
 
+// Text helpers that never touch the game, so the tests can use them: ASCII case and trimming for settings, server
+// timestamps, and ship name matching.
+
 #include <algorithm>
-#include <cctype>
+#include <array>
+#include <charconv>
 #include <chrono>
-#include <sstream>
+#include <cstdint>
+#include <optional>
+#include <span>
 #include <string>
 #include <string_view>
 #include <vector>
 
-#include <il2cpp/il2cpp.h>
-#include <simdutf.h>
-
-#if _WIN32
-#include <winrt/base.h>
-#else
-#include <time.h>
-#endif
-
-inline bool ascii_isspace(unsigned char c)
-{
-  return std::isspace(c);
-}
-
-constexpr std::string_view StripTrailingAsciiWhitespace(const std::string_view str)
-{
-  const auto it = std::find_if_not(str.rbegin(), str.rend(), ascii_isspace);
-  return str.substr(0, static_cast<size_t>(str.rend() - it));
-}
-
-constexpr std::string_view StripLeadingAsciiWhitespace(const std::string_view str)
-{
-  const auto it = std::ranges::find_if_not(str, ascii_isspace);
-  return str.substr(static_cast<size_t>(it - str.begin()));
-}
-
-constexpr std::string_view StripAsciiWhitespace(const std::string_view str)
-{
-  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
-}
+constexpr bool IsAsciiSpace(char c)
+{ return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v'; }
 
-constexpr std::string_view StripSuffix(std::string_view str, const std::string_view suffix)
+constexpr std::string_view StripTrailingAsciiWhitespace(std::string_view str)
 {
-  if (str.size() >= suffix.size() && str.substr(str.size() - suffix.size()) == suffix) {
-    return str.substr(0, str.size() - suffix.size());
-  }
+  while (!str.empty() && IsAsciiSpace(str.back()))
+    str.remove_suffix(1);
   return str;
 }
 
-constexpr std::string_view StripPrefix(std::string_view str, const std::string_view prefix)
+constexpr std::string_view StripLeadingAsciiWhitespace(std::string_view str)
 {
-  if (str.size() >= prefix.size() && str.substr(0, prefix.size()) == prefix) {
-    return str.substr(prefix.size());
-  }
+  while (!str.empty() && IsAsciiSpace(str.front()))
+    str.remove_prefix(1);
   return str;
 }
 
-constexpr std::string AsciiStrToUpper(const std::string_view s)
+constexpr std::string_view StripAsciiWhitespace(std::string_view str)
+{ return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str)); }
+
+constexpr std::string_view StripPrefix(std::string_view str, std::string_view prefix)
+{ return str.starts_with(prefix) ? str.substr(prefix.size()) : str; }
+
+constexpr std::string AsciiStrToUpper(std::string_view s)
 {
-  std::string str = s.data();
-  std::ranges::transform(str, str.begin(), ::toupper);
+  std::string str(s);
+  for (auto& c : str)
+    if (c >= 'a' && c <= 'z')
+      c = static_cast<char>(c - 'a' + 'A');
   return str;
 }
 
-constexpr std::string AsciiStrToLower(const std::string_view s)
+constexpr std::string AsciiStrToLower(std::string_view s)
 {
-  std::string str = s.data();
-  std::ranges::transform(str, str.begin(), ::tolower);
+  std::string str(s);
+  for (auto& c : str)
+    if (c >= 'A' && c <= 'Z')
+      c = static_cast<char>(c - 'A' + 'a');
   return str;
 }
 
-constexpr std::vector<std::string> StrSplit(const std::string& input, const char delimiter)
+// Splits on `delimiter`, trims each piece, and drops the empty ones: "a, ,b" -> {"a", "b"}.
+constexpr std::vector<std::string> StrSplit(std::string_view input, char delimiter)
 {
   std::vector<std::string> result;
-  int                      last_pos = 0;
-  for (int i = 0; i < input.length(); i++) {
-    if (input[i] != delimiter) {
-      continue;
-    }
-
-    if (i - last_pos > 0) {
-      result.emplace_back(input.substr(last_pos, i - last_pos));
-    }
-    last_pos = i + 1;
+  while (true) {
+    const auto end   = input.find(delimiter);
+    const auto token = StripAsciiWhitespace(input.substr(0, end));
+    if (!token.empty())
+      result.emplace_back(token);
+    if (end == std::string_view::npos)
+      return result;
+    input.remove_prefix(end + 1);
   }
+}
 
-  if (last_pos != input.length()) {
-    auto sp = input.substr(last_pos, input.length() - last_pos);
-    sp      = StripAsciiWhitespace(sp);
-    if (!sp.empty()) {
-      result.emplace_back(sp);
+// Seconds since the Unix epoch for a "YYYY-MM-DDTHH:MM:SS" server timestamp, which is UTC. A fraction or
+// zone suffix after the seconds is ignored.
+inline std::optional<int64_t> ParseUtcTimestamp(std::string_view timestamp)
+{
+  using namespace std::chrono;
+  // Field widths and the separator that follows each one.
+  constexpr std::array<std::pair<size_t, char>, 6> kFields{{{4, '-'}, {2, '-'}, {2, 'T'}, {2, ':'}, {2, ':'}, {2, 0}}};
+  std::array<int, 6>                               values{};
+  for (size_t i = 0; i < kFields.size(); ++i) {
+    const auto [width, separator] = kFields[i];
+    if (timestamp.size() < width)
+      return std::nullopt;
+    const auto [end, error] = std::from_chars(timestamp.data(), timestamp.data() + width, values[i]);
+    if (error != std::errc{} || end != timestamp.data() + width)
+      return std::nullopt;
+    timestamp.remove_prefix(width);
+    if (separator) {
+      if (timestamp.empty() || timestamp.front() != separator)
+        return std::nullopt;
+      timestamp.remove_prefix(1);
     }
   }
-
-  return result;
-}
-
-inline std::wstring to_wstring(const std::string& str)
-{
-#if _WIN32
-  return winrt::to_hstring(str).c_str();
-#else
-  size_t                      expected_utf32words = simdutf::utf32_length_from_utf8(str.data(), str.length());
-  std::unique_ptr<char32_t[]> utf32_output{new char32_t[expected_utf32words]};
-  size_t                      utf16words = simdutf::convert_utf8_to_utf32(str.data(), str.length(), utf32_output.get());
-  return std::wstring(utf32_output.get(), utf32_output.get() + utf16words);
-#endif
-}
-
-inline std::wstring to_wstring(Il2CppString* str)
-{
-#if _WIN32
-  return str->chars;
-#else
-  size_t                      expected_utf32words = simdutf::utf32_length_from_utf16(str->chars, str->length);
-  std::unique_ptr<char32_t[]> utf32_output{new char32_t[expected_utf32words]};
-  size_t                      utf16words = simdutf::convert_utf16_to_utf32(str->chars, str->length, utf32_output.get());
-  return std::wstring(utf32_output.get(), utf32_output.get() + utf16words);
-#endif
-}
-
-inline std::string to_string(const std::wstring& str)
-{
-#if _WIN32
-  size_t                     expected_utf16words = simdutf::utf8_length_from_utf16((char16_t*)str.data(), str.length());
-  std::unique_ptr<char8_t[]> utf8_output{new char8_t[expected_utf16words]};
-  size_t utf16words = simdutf::convert_utf16_to_utf8((char16_t*)str.data(), str.length(), (char*)utf8_output.get());
-  return {utf8_output.get(), utf8_output.get() + utf16words};
-#else
-  size_t                     expected_utf32words = simdutf::utf8_length_from_utf32((char32_t*)str.data(), str.length());
-  std::unique_ptr<char8_t[]> utf32_output{new char8_t[expected_utf32words]};
-  size_t utf16words = simdutf::convert_utf32_to_utf8((char32_t*)str.data(), str.length(), (char*)utf32_output.get());
-  return std::string(utf32_output.get(), utf32_output.get() + utf16words);
-#endif
+  const auto [year_, month_, day_, hour, minute, second] = values;
+  const year_month_day date{std::chrono::year{year_}, std::chrono::month(static_cast<unsigned>(month_)),
+                            std::chrono::day(static_cast<unsigned>(day_))};
+  if (!date.ok() || hour > 23 || minute > 59 || second > 60)
+    return std::nullopt;
+  const auto time = sys_days{date} + hours{hour} + minutes{minute} + seconds{second};
+  return time.time_since_epoch() / seconds{1};
 }
 
-inline std::string to_string(const Il2CppString* str)
-{
-  size_t expected_utf8_bytes = simdutf::utf8_length_from_utf16(
-    reinterpret_cast<const char16_t*>(str->chars), str->length);
-  std::string result(expected_utf8_bytes, '\0');
-  size_t actual_utf8_bytes = simdutf::convert_utf16_to_utf8(
-    reinterpret_cast<const char16_t*>(str->chars), str->length, result.data());
-  result.resize(actual_utf8_bytes);
-  return result;
-}
+// Ship names for pinned_ships and the instant_warp_* filters are compared as words, so a setting can name a ship
+// by its last words: "Athena" matches "Academy Athena".
 
-inline bool operator==(const Il2CppString* lhs, const std::string& rhs)
+// Upper case, '_' and '-' as spaces, '.' and '\'' dropped, single spaces, no leading "USS":
+// "U.S.S. Enterprise-D" -> "ENTERPRISE D".
+inline std::string NormalizeShipName(std::string_view name)
 {
-  return to_string(lhs) == rhs;
+  std::string normalized;
+  normalized.reserve(name.size());
+  for (char c : AsciiStrToUpper(name)) {
+    if (c == '.' || c == '\'')
+      continue;
+    if (c == '_' || c == '-')
+      c = ' ';
+    if (c == ' ' && (normalized.empty() || normalized.back() == ' '))
+      continue;
+    normalized.push_back(c);
+  }
+  if (!normalized.empty() && normalized.back() == ' ')
+    normalized.pop_back();
+  return std::string(StripPrefix(normalized, "USS "));
 }
 
-inline bool operator==(const std::string& lhs, const Il2CppString* rhs)
+inline std::vector<std::string> ShipNameWords(std::string_view name)
 {
-  return lhs == to_string(rhs);
+  std::vector<std::string> words;
+  const auto               normalized = NormalizeShipName(name);
+  for (size_t start = 0; start < normalized.size();) {
+    const auto end = std::min(normalized.find(' ', start), normalized.size());
+    words.emplace_back(normalized.substr(start, end - start));
+    start = end + 1;
+  }
+  return words;
 }
 
-inline std::optional<std::chrono::time_point<std::chrono::system_clock>> parse_timestamp(const std::string& timestamp)
+// Whether `pattern` is the last words of `name`; both from ShipNameWords.
+inline bool ShipNameMatches(std::span<const std::string> name, std::span<const std::string> pattern)
 {
-#ifdef _WIN32
-  std::istringstream ss(timestamp);
-  std::chrono::system_clock::time_point time_point;
-
-  if (!std::chrono::from_stream(ss, "%Y-%m-%dT%H:%M:%S", time_point)) {
-    return std::nullopt;
-  }
-
-  return time_point;
-#else
-  std::tm tm = {};
-  if (strptime(timestamp.c_str(), "%Y-%m-%dT%H:%M:%S", &tm) == nullptr) {
-    return std::nullopt;
-  }
-
-  return std::chrono::system_clock::from_time_t(std::mktime(&tm));
-#endif
+  return !pattern.empty() && name.size() >= pattern.size()
+         && std::ranges::equal(name.subspan(name.size() - pattern.size()), pattern);
 }
diff --git a/mods/src/titlelinux.h b/mods/src/titlelinux.h
deleted file mode 100644
index 78a1c2360..000000000
--- a/mods/src/titlelinux.h
+++ /dev/null
@@ -1,54 +0,0 @@
-#pragma once
-#ifdef _WIN32
-#elif defined(__APPLE__)
-#else
-
-#include <X11/Xatom.h>
-#include <X11/Xlib.h>
-#include <string>
-
-inline std::wstring WindowTitle::Get()
-{
-  Display* dpy = XOpenDisplay(nullptr);
-  if (!dpy)
-    return L"";
-
-  Window         root = DefaultRootWindow(dpy);
-  Atom           prop = XInternAtom(dpy, "_NET_WM_NAME", False);
-  Atom           type;
-  int            format;
-  unsigned long  nitems, bytes_after;
-  unsigned char* prop_ret = nullptr;
-  std::wstring   title;
-
-  if (XGetWindowProperty(dpy, root, prop, 0, 1024, False, AnyPropertyType, &type, &format, &nitems, &bytes_after,
-                         &prop_ret)
-      == Success) {
-    if (prop_ret) {
-      std::string s(reinterpret_cast<char*>(prop_ret), nitems);
-      title.assign(s.begin(), s.end()); // simple UTF-8 -> wstring conversion
-      XFree(prop_ret);
-    }
-  }
-
-  XCloseDisplay(dpy);
-  return title;
-}
-
-inline bool WindowTitle::Set(const std::wstring& title)
-{
-  Display* dpy = XOpenDisplay(nullptr);
-  if (!dpy)
-    return false;
-
-  Window      root = DefaultRootWindow(dpy);
-  std::string s(title.begin(), title.end()); // simple conversion to UTF-8
-
-  int result = XStoreName(dpy, root, s.c_str());
-  XFlush(dpy);
-  XCloseDisplay(dpy);
-
-  return result != 0; // returns true if successful
-}
-
-#endif
diff --git a/mods/src/titlemac.mm b/mods/src/titlemac.mm
deleted file mode 100644
index 51f04d659..000000000
--- a/mods/src/titlemac.mm
+++ /dev/null
@@ -1,36 +0,0 @@
-#ifdef __APPLE__
-
-#include "windowtitle.h"
-#import <Cocoa/Cocoa.h>
-
-std::wstring WindowTitle::Get()
-{
-    @autoreleasepool {
-        NSWindow *window = [NSApp mainWindow];
-        if (!window) window = [NSApp keyWindow];
-        if (!window) return L"";
-
-        NSString *title = [window title];
-        if (!title) return L"";
-
-        std::wstring wtitle([title length], L'\0');
-        [title getCharacters:(unichar*)wtitle.data() range:NSMakeRange(0, [title length])];
-        return wtitle;
-    }
-}
-
-bool WindowTitle::Set(const std::wstring& title)
-{
-    @autoreleasepool {
-        NSWindow *window = [NSApp mainWindow];
-        if (!window) window = [NSApp keyWindow];
-        if (!window) return false;
-
-        NSString *nsTitle = [NSString stringWithCharacters:(const unichar*)title.data() length:title.size()];
-        [window setTitle:nsTitle];
-        
-        return true;
-    }
-}
-
-#endif
diff --git a/mods/src/titlewindows.h b/mods/src/titlewindows.h
deleted file mode 100644
index 0a915ecf0..000000000
--- a/mods/src/titlewindows.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#ifdef _WIN32
-
-#include "config.h"
-#include <Windows.h>
-#include <string>
-
-inline std::wstring WindowTitle::Get()
-{
-  HWND hwnd = Config::WindowHandle();
-  if (!hwnd)
-    return L"";
-
-  int length = GetWindowTextLengthW(hwnd);
-  if (length == 0)
-    return L"";
-
-  std::wstring title(length + 1, L'\0');
-
-  int written = GetWindowTextW(hwnd, title.data(), length + 1);
-  title.resize(written);
-
-  return title;
-}
-
-inline bool WindowTitle::Set(const std::wstring& title)
-{
-  HWND hwnd = Config::WindowHandle();
-  if (!hwnd)
-    return false;
-
-  return SetWindowTextW(hwnd, title.c_str()) != 0;
-}
-
-#elif defined(__APPLE__)
-#else
-#endif
diff --git a/mods/src/windowtitle.h b/mods/src/windowtitle.h
deleted file mode 100644
index 62d742cdb..000000000
--- a/mods/src/windowtitle.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-#include <string>
-
-struct WindowTitle {
-  // Get the window title
-  static std::wstring Get();
-
-  // Set the window title
-  static bool Set(const std::wstring& title);
-};
-
-#include "titlewindows.h"
-#include "titlelinux.h"
diff --git a/mods/xmake.lua b/mods/xmake.lua
index aa6881062..ccdba4da7 100644
--- a/mods/xmake.lua
+++ b/mods/xmake.lua
@@ -56,7 +56,7 @@ do
         end
 
         local assets = path.join(target:scriptdir(), "../assets")
-        local outdir  = path.join(target:scriptdir(), "src/patches/parts")
+        local outdir  = path.join(target:scriptdir(), "src/features")
 
         local loading = get_config("bg_image")
         if not loading or loading == "" then
@@ -89,12 +89,13 @@ do
         add_rules("stfc.cxx.sccache", {override = true})
     end
     add_files("src/**.cc")
+    add_deps("unity", {public = true})
     add_deps("il2cpp", {public = true})
     add_headerfiles("src/**.h")
     add_includedirs("src", { public = true })
 
     -- Packages
-    add_packages("spud", "nlohmann_json", "protobuf", "libil2cpp", "eastl", "toml++", "spdlog", "simdutf", "libcurl", "capstone", "cpr")
+    add_packages("spud", "nlohmann_json", "protobuf", "libil2cpp", "eastl", "toml++", "spdlog", "libcurl", "capstone", "cpr")
     if os.getenv("STFC_PROTOBUF_SCCACHE") == "1" then
         add_rules("stfc.protobuf.cpp.sccache")
     else
diff --git a/scripts/check-il2cpp-dump.py b/scripts/check-il2cpp-dump.py
index 8de4c635f..76d507356 100755
--- a/scripts/check-il2cpp-dump.py
+++ b/scripts/check-il2cpp-dump.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Check the IL2CPP bindings in mods/src against an Il2CppDumper dump.cs.
+"""Check the IL2CPP bindings under src/ against an Il2CppDumper dump.cs.
 
   check-il2cpp-dump.py check <dump.cs> [--old <dump.cs>]
       Every binding class, member and hook target used in the source must exist in the dump with
@@ -21,7 +21,7 @@
 import re
 from collections import defaultdict
 
-SRC_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'mods', 'src')
+SRC_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
 
 TYPE_HEAD = re.compile(
     r'^(?:\[.*\]\s*)?(?:(?:public|private|protected|internal|static|sealed|abstract|readonly|ref|unsafe|partial)\s+)*'
@@ -137,7 +137,10 @@ def lookup(self, cls, kind, member):
 
 CLASS = r'il2cpp::Class<\s*"([^"]*)"\s*,\s*"([^"]*)"\s*,\s*"([^"]*)"\s*>'
 USE = re.compile(r'(?<![\w:])(Class::)?(Get|Set|Field|SetField|Call)<\s*"([^"]+)"')
-HOOK = re.compile(r'(?<![\w:])(\w+)::(?:Class::)?Method\(\s*"([^"]+)"\s*(?:,\s*(\d+|\{[^}]*\}))?\)')
+# The owner may carry a namespace: unity::Cursor::Method("SetCursor_Injected").
+HOOK = re.compile(r'(?<![\w:])(?:\w+::)*?(\w+)::(?:Class::)?Method\(\s*"([^"]+)"\s*(?:,\s*(\d+|\{[^}]*\}))?\)')
+# Static uses through a class alias outside any binding struct: ObjectClass::Call<"Destroy">(object).
+ALIAS_USE = re.compile(r'(?<![\w:])(\w+)::(Get|Set|Field|SetField|Call)<\s*"([^"]+)"')
 KIND = {'Get': 'prop', 'Set': 'prop', 'Field': 'field', 'SetField': 'field', 'Call': 'method'}
 
 
@@ -158,7 +161,8 @@ def call_arity(text):
 def scan_source(root):
     """Returns ({binding name: (asm, ns, class)}, [(file, owner, kind, member, static, arity)])."""
     classes, uses = {}, []
-    for dirpath, _, files in os.walk(root):
+    for dirpath, _, files in (entry for directory in ('mods/src', 'libs')
+                              for entry in os.walk(os.path.join(root, directory))):
         if os.sep + 'proto' in dirpath:
             continue
         for f in files:
@@ -166,8 +170,16 @@ def scan_source(root):
                 continue
             path = os.path.join(dirpath, f)
             text = open(path, encoding='utf-8', errors='replace').read()
+            aliases = set()
             for m in re.finditer(r'using\s+(\w+)\s*=\s*' + CLASS, text):
                 classes.setdefault(m.group(1), m.group(2, 3, 4))
+                if m.group(1) != 'Class':
+                    aliases.add(m.group(1))
+            for u in ALIAS_USE.finditer(text):
+                if u.group(1) in aliases:
+                    kind = KIND[u.group(2)]
+                    arity = call_arity(text[u.end():]) if kind == 'method' else None
+                    uses.append((path, u.group(1), kind, u.group(3), True, arity))
             for m in re.finditer(r'^\s*struct\s+(\w+)[^;{]*\{', text, re.M):
                 i, depth = m.end(), 1
                 while i < len(text) and depth:
diff --git a/tests/chat_startup.cc b/tests/chat_startup.cc
deleted file mode 100644
index 32daffcb6..000000000
--- a/tests/chat_startup.cc
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "patches/chat_startup.h"
-#include <cassert>
-#include <iostream>
-
-int main()
-{
-  ChatStartup::Gate gate;
-  // Slow initial load must never open, regardless of elapsed wall time.
-  assert(!gate.Tick(false, false, 0));
-  assert(!gate.Tick(false, false, 100));
-  assert(!gate.Tick(true, false, 101));
-  assert(!gate.Tick(true, false, 103.99));
-  // A transition or lost readiness restarts the full settling period.
-  assert(!gate.Tick(false, false, 104));
-  assert(!gate.Tick(true, false, 110));
-  assert(!gate.Tick(true, false, 112.99));
-  assert(gate.Tick(true, false, 113));
-  assert(!gate.Tick(true, false, 200)); // User closes chat: do not reopen.
-  gate = {}; // Login/reload permits one new open.
-  assert(!gate.Tick(true, false, 201));
-  assert(gate.Tick(true, false, 204));
-  gate = {};
-  assert(!gate.Tick(false, true, 205)); // Manual chat wins, even before readiness.
-  assert(!gate.Tick(true, false, 300));
-  assert(!gate.Tick(true, false, 303));
-  std::cout << "Chat startup readiness regression tests passed\n";
-}
diff --git a/tests/il2cpp_bindings.cc b/tests/il2cpp_bindings.cc
index 55c1b7f96..c1da93b59 100644
--- a/tests/il2cpp_bindings.cc
+++ b/tests/il2cpp_bindings.cc
@@ -369,6 +369,13 @@ END_API
 API(const Il2CppType*, il2cpp_class_get_type, (Il2CppClass * klass))
 { return &klass->byval_arg; }
 END_API
+API(Il2CppMethodPointer, il2cpp_resolve_icall, (const char* name))
+{
+  // The only internal call the fake runtime has.
+  static constexpr auto answer = +[]() -> int32_t { return 42; };
+  return std::string_view(name) == "Test::Answer()" ? reinterpret_cast<Il2CppMethodPointer>(answer) : nullptr;
+}
+END_API
 API(Il2CppObject*, il2cpp_type_get_object, (const Il2CppType*))
 { return &type_object; }
 END_API
@@ -597,6 +604,13 @@ int main()
   Require(base->Call<"Explode", int32_t>() == 0 && base->Call<"Explode", int32_t>() == 0, "exception contained");
   Require(ErrorsMentioning("Game.Base.Explode threw: NullReferenceException") == 1, "exception reported once");
 
+  // Internal calls run when present; a missing one is reported once and returns the default.
+  static const auto answer  = il2cpp::ResolveICall<int32_t()>("Test::Answer()");
+  static const auto renamed = il2cpp::ResolveICall<int32_t()>("Test::Renamed()");
+  Require(answer && answer() == 42, "internal call");
+  Require(!renamed && renamed() == 0 && renamed() == 0, "missing internal call returns the default");
+  Require(ErrorsMentioning("missing internal call Test::Renamed()") == 1, "missing internal call reported once");
+
   // Nested classes resolve through their declaring type.
   Require(il2cpp::Class<"Game", "Game", "Outer/Inner">::Raw() == &inner_class.klass, "nested class");
 
@@ -608,6 +622,9 @@ int main()
   for (auto* item : *second)
     items += item != nullptr;
   Require(items == 3 && (*first)[0] == &list_a.header, "list iteration");
+  Require(first->Method<int32_t()>("get_Count").Pointer() == reinterpret_cast<void*>(&ListA_get_Count),
+          "runtime collection method schema");
+  Require(!first->Method<int32_t(int32_t)>("get_Item"), "runtime collection schema rejects a value result");
 
   // Fully shared generic code is marshalled by the runtime.
   Require(base->Call<"Shared", int32_t>() == 41 && boxed_invocations == 1, "shared generic fallback");
@@ -624,6 +641,40 @@ int main()
   Require(Base::Class::Method("Select", {"System.Boolean"}).Pointer() == reinterpret_cast<void*>(&Base_Select_Bool),
           "hook lookup by parameter types");
   Require(!Base::Class::Method("Absent", 0) && ErrorsMentioning("missing method Game.Base.Absent"), "missing hook");
+  Require(Base::Class::Method("OnEvent").Name() == "Game.Base.OnEvent", "method name for diagnostics");
+
+  Require(Base::Class::Method<void(bool)>("Select").Pointer() == reinterpret_cast<void*>(&Base_Select_Bool),
+          "typed hook lookup selects the complete instance signature");
+  Require(!Base::Class::Method<int32_t(bool)>("Select"), "typed hook lookup rejects a changed return type");
+  Require(!Base::Class::Method<int32_t(int32_t)>("Twice"), "instance hook lookup rejects a static method");
+  Require(!Base::Class::Method<int32_t()>("Shared"), "typed hook lookup rejects fully shared generic code");
+  Require(Base::Class::HasField<"_count", int32_t>(), "instance field schema accepts the declared type");
+  Require(!Base::Class::HasField<"_count", Other*>(), "instance field schema rejects an incompatible type");
+  Require(!Base::Class::HasField<"s_flag", int32_t>(), "instance field schema rejects a static field");
+
+  // Managed strings convert to UTF-8, and compare with ASCII without converting.
+  const auto utf16 = [](std::u16string_view text) {
+    auto* str   = static_cast<Il2CppString*>(std::calloc(1, sizeof(Il2CppString) + text.size() * sizeof(Il2CppChar)));
+    str->length = static_cast<int32_t>(text.size());
+    std::copy(text.begin(), text.end(), str->chars);
+    return str;
+  };
+  auto* mixed = utf16(u"K\u00E9rk \u2192 \U0001F596");
+  Require(il2cpp::ToUtf8(mixed) == "K\xC3\xA9rk \xE2\x86\x92 \xF0\x9F\x96\x96",
+          "UTF-16 to UTF-8 with a surrogate pair");
+  auto* lone = utf16(std::u16string_view(u"a\xD800"
+                                         "b",
+                                         3));
+  Require(il2cpp::ToUtf8(lone)
+              == "a\xEF\xBF\xBD"
+                 "b",
+          "a lone surrogate becomes U+FFFD");
+  Require(il2cpp::ToUtf8(nullptr).empty(), "null string");
+  auto* ascii = utf16(u"Galaxy");
+  Require(il2cpp::Equals(ascii, "Galaxy") && !il2cpp::Equals(ascii, "Galax") && !il2cpp::Equals(nullptr, ""),
+          "ASCII comparison");
+  for (auto* str : {mixed, lone, ascii})
+    std::free(str);
 
   // TryCall tells a failed call apart from a result that reads as zero.
   Require(!base->TryCall<"Explode", int32_t()>() && ErrorsMentioning("Game.Base.Explode threw") == 1,
diff --git a/tests/mod_logic.cc b/tests/mod_logic.cc
new file mode 100644
index 000000000..d23dc00a8
--- /dev/null
+++ b/tests/mod_logic.cc
@@ -0,0 +1,270 @@
+// Settings parsing and shortcut matching, run against production code with Unity input replaced by a fake.
+#include "patches/chat_startup.h"
+#include "patches/parts/toast_text.h"
+#include "patches/ship_shortcut_hint.h"
+#include "patches/shortcuts.h"
+#include "str_utils.h"
+
+#include <toml++/toml.h>
+#include <unity/input.h>
+
+#include <array>
+#include <cstdlib>
+#include <iostream>
+#include <source_location>
+
+namespace
+{
+std::array<bool, static_cast<size_t>(unity::KeyCode::Max)> held{};
+int                                                        failures = 0;
+
+void Check(bool condition, const char* what, std::source_location where = std::source_location::current())
+{
+  if (!condition) {
+    std::cerr << where.file_name() << ":" << where.line() << ": " << what << '\n';
+    ++failures;
+  }
+}
+
+void Hold(std::initializer_list<unity::KeyCode> keys)
+{
+  held.fill(false);
+  for (auto key : keys)
+    held[static_cast<size_t>(key)] = true;
+}
+
+toml::table Load(std::string_view settings, bool extended = true, bool experimental = false)
+{
+  Shortcut::Clear();
+  toml::table parsed;
+  Shortcut::Load(toml::parse(settings), parsed, extended, experimental);
+  return parsed;
+}
+
+std::string Value(const toml::table& parsed, std::string_view section, std::string_view key)
+{ return parsed[section][key].value_or(std::string("<missing>")); }
+
+void ShipHints()
+{
+  Shortcut::Clear();
+  // A locked dock F leaves native G at the sixth selectable position (the reported 1,2,3,4,5,7 layout).
+  const std::array gapped_fleets{0, 1, 2, 3, 4, 6};
+  auto             ship_hint = [&](Action action) {
+    return ShipShortcutHintAction(action, gapped_fleets.size(), [&](std::size_t i) { return gapped_fleets[i]; });
+  };
+  Check(ship_hint(Action::kSelectShip7) == Action::kSelectShip6,
+        "Native ship G must advertise the sixth mod shortcut when dock F is locked");
+  Check(ship_hint(Action::kSelectShip5) == Action::kSelectShip5, "Earlier ship hints must stay unchanged");
+  Check(ship_hint(Action::kSelectShip6) == Action::kCount, "Missing dock must not advertise a shortcut");
+  Check(ship_hint(Action::kShowGalaxy) == Action::kShowGalaxy, "Non-ship hint mapping changed");
+  Check(ShipShortcutHintAction(Action::kSelectShip1, 0, [](std::size_t) { return 0; }) == Action::kCount,
+        "Unavailable fleet context must not advertise a guessed ship shortcut");
+  for (int index = 0; index < 8; ++index) {
+    auto action = static_cast<Action>(static_cast<int>(Action::kSelectShip1) + index);
+    Check(ShipShortcutHintAction(action, 8, [](std::size_t i) { return static_cast<int>(i); }) == action,
+          "Contiguous eight-dock hints must keep their original shortcuts");
+  }
+  const std::array reordered_fleets{7, 0, 2, -1, 6, 4, 1, 3, 5};
+  auto             reordered_hint = [&](Action action) {
+    return ShipShortcutHintAction(action, reordered_fleets.size(), [&](std::size_t i) { return reordered_fleets[i]; });
+  };
+  Check(reordered_hint(Action::kSelectShip8) == Action::kSelectShip1, "Ship hints must follow bar order");
+  Check(reordered_hint(Action::kSelectShip7) == Action::kSelectShip5,
+        "Null fleet entries must preserve the positions passed to RequestSelect");
+  Check(reordered_hint(Action::kSelectShip6) == Action::kCount,
+        "Fleet beyond the eight supported mod shortcuts must not advertise a shortcut");
+  Check(Shortcut::Hint(ship_hint(Action::kSelectShip7)).empty(),
+        "Unbound ship selection must not advertise a working shortcut");
+  Shortcut::Bind(Action::kSelectShip6, KeyChord::Parse("CTRL-F8"));
+  Check(Shortcut::Hint(ship_hint(Action::kSelectShip7)) == "^F8",
+        "Gapped ship hint must use the actual custom binding, not a hardcoded number");
+}
+
+void StringHelpers()
+{
+  Check(StrSplit(" a, ,b ,", ',') == std::vector<std::string>{"a", "b"}, "StrSplit trims and drops empty tokens");
+  Check(StrSplit("", ',').empty(), "StrSplit of nothing");
+  // A view into a longer string must not pick up the text after it.
+  constexpr std::string_view padded = " warp  ";
+  Check(AsciiStrToUpper(StripAsciiWhitespace(padded)) == "WARP", "upper-casing a trimmed view");
+  Check(AsciiStrToLower("FeDeRaTiOn") == "federation", "lower-casing");
+}
+
+void Timestamps()
+{
+  Check(ParseUtcTimestamp("1970-01-01T00:00:00") == 0, "epoch");
+  Check(ParseUtcTimestamp("2024-05-01T12:34:56Z") == 1714566896, "UTC with zone suffix");
+  Check(ParseUtcTimestamp("2024-05-01T12:34:56.789Z") == 1714566896, "fraction ignored");
+  Check(ParseUtcTimestamp("2024-02-30T00:00:00") == std::nullopt, "invalid date");
+  Check(ParseUtcTimestamp("2024-05-01 12:34:56") == std::nullopt, "wrong separator");
+  Check(ParseUtcTimestamp("") == std::nullopt, "empty");
+}
+
+void ToastText()
+{
+  using namespace toast_text;
+  const std::vector<std::string> values{"Kirk", "7", ""};
+  Check(FormatPlaceholders("{0} scored {1}", values) == "Kirk scored 7", "plain placeholders");
+  Check(FormatPlaceholders("Lv.{1:000}", values) == "Lv.007", "zero-padded placeholder");
+  Check(FormatPlaceholders("{0}{0}", values) == "KirkKirk", "repeated placeholder");
+  Check(FormatPlaceholders("{10} and {1}", values) == "{10} and 7", "{1} does not match {10}");
+  Check(FormatPlaceholders("{2} stays", values) == "{2} stays", "empty values are left alone");
+  Check(FormatPlaceholders("{1:x2}", values) == "7", "other formats are filled unpadded");
+  Check(StripRichText("<color=#FF0000>Red</color> <b>bold</b>") == "Red bold", "rich text tags removed");
+  Check(StripRichText("a < b") == "a < b", "an unclosed '<' is text");
+  Check(TitleCase("USS ENTERPRISE-D") == "Uss Enterprise-D", "title case");
+  Check(HullKeyName("Hull_L30_Destroyer_Klingon_LIVE") == "Lv.30 Destroyer Klingon", "hull key with level");
+  Check(HullKeyName("Hull_BORG_CUBE") == "Borg Cube", "hull key without level");
+}
+
+void ShipNames()
+{
+  Check(NormalizeShipName("  U.S.S. Enterprise-D ") == "ENTERPRISE D", "ship names drop USS and punctuation");
+  Check(NormalizeShipName("d'deridex__b") == "DDERIDEX B", "ship names collapse separators");
+  const auto academy = ShipNameWords("Academy Athena");
+  Check(ShipNameMatches(academy, ShipNameWords("athena")), "a ship name matches its last word");
+  Check(ShipNameMatches(academy, ShipNameWords("ACADEMY ATHENA")), "a ship name matches all its words");
+  Check(!ShipNameMatches(academy, ShipNameWords("academy")), "a ship name does not match its first word");
+  Check(!ShipNameMatches(academy, ShipNameWords("")), "an empty pattern matches nothing");
+  Check(!ShipNameMatches(ShipNameWords("Thena"), ShipNameWords("Athena")), "words match whole");
+}
+
+void Chords()
+{
+  const auto chord = KeyChord::Parse("ctrl-shift-f1");
+  Check(chord.key == unity::KeyCode::F1, "chord key");
+  Check(chord.modifiers.size() == 2, "chord modifiers");
+  Check(chord.Text() == "CTRL-SHIFT-F1", "chord text");
+  Check(chord.Hint() == "^+F1", "chord badge");
+  Check(KeyChord::Parse("SHIFT-+").Hint() == "+PLS", "plus key as the primary key");
+  Check(KeyChord::Parse("CTRL").key == unity::KeyCode::None, "modifier alone has no key");
+  Check(KeyChord::Parse("NONSENSE").key == unity::KeyCode::None, "unknown key");
+  Check(KeyChord::Parse("CTRL-A-B").key == unity::KeyCode::B && KeyChord::Parse("CTRL-A-B").Text() == "CTRL-B",
+        "with two keys the last counts, and the text shows it");
+  Check(KeyChord::Parse("pgup-lshift").Hint() == "<+PU", "modifiers come first in the badge");
+}
+
+void Loading()
+{
+  auto parsed = Load(R"(
+    [shortcuts]
+    show_galaxy = "CTRL-G | F8"
+    show_system = ""
+    show_events = "BOGUS"
+    quit = 42
+    set_hotkeys_disble = "F3"
+  )");
+  Check(Shortcut::Describe(Action::kShowGalaxy) == "CTRL-G | F8", "both alternatives bound");
+  Check(Shortcut::Hint(Action::kShowGalaxy) == "^G", "badge shows the first alternative");
+  Check(Value(parsed, "shortcuts", "show_galaxy") == "CTRL-G | F8", "vars records the bindings");
+  Check(Value(parsed, "shortcuts_source", "show_galaxy") == "config", "source is the settings file");
+
+  Check(!Shortcut::HasBinding(Action::kShowSystem), "an empty string disables the binding");
+  Check(Value(parsed, "shortcuts", "show_system") == "NONE", "disabled binding recorded as NONE");
+
+  Check(Shortcut::Describe(Action::kShowEvents) == std::string("SHIFT-E"),
+        "a binding with no valid key falls back to the default");
+  Check(Value(parsed, "shortcuts_source", "show_events") == "default", "fallback recorded as default");
+  Check(Shortcut::Describe(Action::kQuit) == std::string("F10"), "a non-string falls back too");
+
+  Check(Shortcut::Describe(Action::kDisableHotKeys) == "F3", "deprecated alias still binds");
+  Check(Value(parsed, "shortcuts_source", "set_hotkeys_disabled") == "alias:set_hotkeys_disble", "alias source");
+
+  Check(Shortcut::HasBinding(Action::kShowBookmarks), "extended shortcuts load when extended");
+  Shortcut::Bind(Action::kQuit, KeyChord::Parse("F1"));
+  Shortcut::Load(toml::table{}, parsed, true, false);
+  Check(Shortcut::Describe(Action::kQuit) == "F10", "loading again replaces earlier bindings");
+  Check(!Shortcut::HasBinding(Action::kShowLookup), "experimental shortcuts need experimental");
+  parsed = Load("", false);
+  Check(!Shortcut::HasBinding(Action::kShowBookmarks), "extended shortcuts are skipped otherwise");
+  Check(Value(parsed, "shortcuts", "show_bookmarks") == "<missing>", "skipped shortcuts are not recorded");
+}
+
+void Matching()
+{
+  Load(""); // defaults: move_down = "S|DOWN", toggle_shortcut_hints = "HOME"
+
+  Hold({unity::KeyCode::DownArrow});
+  Check(Shortcut::IsPressed(Action::kMoveDown), "default movement key");
+  for (auto modifier : {unity::KeyCode::LeftControl, unity::KeyCode::RightShift, unity::KeyCode::LeftAlt,
+                        unity::KeyCode::LeftCommand}) {
+    Hold({unity::KeyCode::DownArrow, modifier});
+    Check(!Shortcut::IsPressed(Action::kMoveDown), "a modified chord must not trigger the plain binding");
+  }
+  Hold({});
+  Check(!Shortcut::IsPressed(Action::kMoveDown), "released key");
+
+  // Releasing the modifier first must not turn a held CTRL-PGUP into PGUP.
+  Load(""); // ui_scaleup = "PGUP", ui_scaleshipup = "CTRL-PGUP"
+  Hold({unity::KeyCode::LeftControl, unity::KeyCode::PageUp});
+  Check(Shortcut::IsPressed(Action::kUiShipScaleUp), "modified chord");
+  Check(!Shortcut::IsPressed(Action::kUiScaleUp), "plain chord blocked while modified");
+  Check(Shortcut::Owns(unity::KeyCode::PageUp), "the modified chord owns its key");
+  Hold({unity::KeyCode::PageUp});
+  Check(!Shortcut::IsPressed(Action::kUiScaleUp), "plain chord waits for the key's release");
+  Hold({});
+  Check(!Shortcut::Owns(unity::KeyCode::PageUp), "releasing the key frees it");
+  Hold({unity::KeyCode::PageUp});
+  Check(Shortcut::IsPressed(Action::kUiScaleUp), "plain chord after a release");
+
+  // A modified movement binding keeps moving while its modifier is held.
+  Shortcut::Bind(Action::kMoveDown, KeyChord::Parse("CTRL-DOWN"));
+  Hold({unity::KeyCode::LeftControl, unity::KeyCode::DownArrow});
+  Check(Shortcut::IsDown(Action::kMoveDown) && Shortcut::IsDown(Action::kMoveDown),
+        "explicit movement chord keeps matching");
+  held.fill(false);
+}
+} // namespace
+
+// The fake Unity input that the shortcut code reads.
+namespace unity::Key
+{
+bool Pressed(unity::KeyCode key)
+{ return held[static_cast<size_t>(key)]; }
+bool Down(unity::KeyCode key)
+{ return Pressed(key); }
+bool IsModified()
+{
+  for (auto key : {unity::KeyCode::LeftControl, unity::KeyCode::RightControl, unity::KeyCode::LeftShift,
+                   unity::KeyCode::RightShift, unity::KeyCode::LeftAlt, unity::KeyCode::RightAlt,
+                   unity::KeyCode::LeftCommand, unity::KeyCode::RightCommand})
+    if (Pressed(key))
+      return true;
+  return false;
+}
+} // namespace unity::Key
+
+void ChatStartupGate()
+{
+  ChatStartup::Gate gate;
+  // A slow initial load never opens, whatever the elapsed wall time.
+  Check(!gate.Tick(false, false, 0) && !gate.Tick(false, false, 100), "chat gate waits while not ready");
+  Check(!gate.Tick(true, false, 101) && !gate.Tick(true, false, 103.99), "chat gate waits three seconds");
+  // A transition or lost readiness restarts the full settling period.
+  Check(!gate.Tick(false, false, 104) && !gate.Tick(true, false, 110) && !gate.Tick(true, false, 112.99),
+        "lost readiness restarts the chat gate");
+  Check(gate.Tick(true, false, 113), "chat gate opens after three ready seconds");
+  Check(!gate.Tick(true, false, 200), "chat gate opens once; a closed chat is not reopened");
+  gate = {}; // Login or reload permits one new open.
+  Check(!gate.Tick(true, false, 201) && gate.Tick(true, false, 204), "a reset chat gate opens again");
+  gate = {};
+  Check(!gate.Tick(false, true, 205) && !gate.Tick(true, false, 300) && !gate.Tick(true, false, 303),
+        "chat already open consumes the gate, even before readiness");
+}
+
+int main()
+{
+  ShipHints();
+  StringHelpers();
+  Timestamps();
+  ToastText();
+  ShipNames();
+  Chords();
+  Loading();
+  Matching();
+  ChatStartupGate();
+  if (failures)
+    return EXIT_FAILURE;
+  std::cout << "mod logic tests passed\n";
+  return EXIT_SUCCESS;
+}
diff --git a/tests/run-shortcut-hint-cache.ps1 b/tests/run-shortcut-hint-cache.ps1
deleted file mode 100644
index 8e9c40bb0..000000000
--- a/tests/run-shortcut-hint-cache.ps1
+++ /dev/null
@@ -1,22 +0,0 @@
-# Run after zig build mods il2cpp -Dtarget=x86_64-windows-msvc -Dmoddbg=true -Dlto=false.
-# Uses production MapKey/ModifierKey objects from mods.lib; does not launch or modify the game.
-[CmdletBinding()]
-param()
-
-$ErrorActionPreference = 'Stop'
-$repoRoot = Split-Path -Parent $PSScriptRoot
-Push-Location $repoRoot
-try {
-    if (-not (Test-Path -LiteralPath 'zig-out/lib/mods.lib') -or -not (Test-Path -LiteralPath 'zig-out/lib/il2cpp.lib')) {
-        throw 'Build the mods and il2cpp targets with -Dlto=false first.'
-    }
-    # Use Microsoft link.exe for the Windows static CRT and import libraries.
-    & clang++ --driver-mode=cl -fuse-ld=link /std:c++latest /EHsc /MT /Imods/src /Ilibs/il2cpp/include `
-        tests/shortcut_hint_cache.cc /Fozig-out/bin/shortcut_hint_cache.obj /Fezig-out/bin/shortcut_hint_cache.exe `
-        /link /LTCG /LIBPATH:libs/il2cpp zig-out/lib/mods.lib zig-out/lib/il2cpp.lib
-    if ($LASTEXITCODE -ne 0) { throw 'Shortcut hint test compilation failed.' }
-    & ./zig-out/bin/shortcut_hint_cache.exe
-    if ($LASTEXITCODE -ne 0) { throw 'Shortcut hint cache regression failed.' }
-} finally {
-    Pop-Location
-}
diff --git a/tests/shortcut_hint_cache.cc b/tests/shortcut_hint_cache.cc
deleted file mode 100644
index affb21e10..000000000
--- a/tests/shortcut_hint_cache.cc
+++ /dev/null
@@ -1,147 +0,0 @@
-// Link against the built mods library. Only Unity-dependent Key operations are stubbed;
-// MapKey parsing, ModifierKey parsing, binding detection, and hint caching are production code.
-#include "defaultconfig.h"
-#include "patches/mapkey.h"
-#include "patches/ship_shortcut_hint.h"
-#include <array>
-
-#include <cstdlib>
-#include <iostream>
-
-static std::array<bool, static_cast<int>(KeyCode::Max)> held{};
-static KeyCode claimed = KeyCode::None;
-
-KeyCode Key::Parse(std::string_view key)
-{
-  if (key == "F7") return KeyCode::F7;
-  if (key == "F8") return KeyCode::F8;
-  if (key == "G") return KeyCode::G;
-  for (const auto [token, code] : {std::pair{"W", KeyCode::W}, {"A", KeyCode::A}, {"S", KeyCode::S},
-                                   {"D", KeyCode::D}, {"UP", KeyCode::UpArrow}, {"DOWN", KeyCode::DownArrow},
-                                   {"LEFT", KeyCode::LeftArrow}, {"RIGHT", KeyCode::RightArrow}})
-    if (key == token) return code;
-  return KeyCode::None;
-}
-bool Key::IsModifier(KeyCode) { return false; }
-bool Key::Pressed(KeyCode key) { return held[static_cast<int>(key)]; }
-bool Key::Down(KeyCode key) { return Key::Pressed(key); }
-bool Key::IsModified() {
-  for (auto key : {KeyCode::LeftControl, KeyCode::RightControl, KeyCode::LeftShift, KeyCode::LeftAlt, KeyCode::LeftCommand})
-    if (Key::Pressed(key)) return true;
-  return false;
-}
-void Key::ClaimDirectionalInput(KeyCode key) { claimed = key; }
-
-void Check(bool condition, const char* message)
-{
-  if (!condition) {
-    std::cerr << message << '\n';
-    std::exit(1);
-  }
-}
-
-int main()
-{
-  // A locked dock F leaves native G at the sixth selectable position (the reported 1,2,3,4,5,7 layout).
-  const std::array gapped_fleets{0, 1, 2, 3, 4, 6};
-  auto             ship_hint = [&](GameFunction action) {
-    return ShipShortcutHintAction(action, gapped_fleets.size(), [&](std::size_t i) { return gapped_fleets[i]; });
-  };
-  Check(ship_hint(GameFunction::SelectShip7) == GameFunction::SelectShip6,
-        "Native ship G must advertise the sixth mod shortcut when dock F is locked");
-  Check(ship_hint(GameFunction::SelectShip5) == GameFunction::SelectShip5, "Earlier ship hints must stay unchanged");
-  Check(ship_hint(GameFunction::SelectShip6) == GameFunction::Max, "Missing dock must not advertise a shortcut");
-  Check(ship_hint(GameFunction::ShowGalaxy) == GameFunction::ShowGalaxy, "Non-ship hint mapping changed");
-  Check(ShipShortcutHintAction(GameFunction::SelectShip1, 0, [](std::size_t) { return 0; }) == GameFunction::Max,
-        "Unavailable fleet context must not advertise a guessed ship shortcut");
-  for (int index = 0; index < 8; ++index) {
-    auto action = static_cast<GameFunction>(GameFunction::SelectShip1 + index);
-    Check(ShipShortcutHintAction(action, 8, [](std::size_t i) { return static_cast<int>(i); }) == action,
-          "Contiguous eight-dock hints must keep their original shortcuts");
-  }
-  const std::array reordered_fleets{7, 0, 2, -1, 6, 4, 1, 3, 5};
-  auto             reordered_hint = [&](GameFunction action) {
-    return ShipShortcutHintAction(action, reordered_fleets.size(), [&](std::size_t i) { return reordered_fleets[i]; });
-  };
-  Check(reordered_hint(GameFunction::SelectShip8) == GameFunction::SelectShip1, "Ship hints must follow bar order");
-  Check(reordered_hint(GameFunction::SelectShip7) == GameFunction::SelectShip5,
-        "Null fleet entries must preserve the positions passed to RequestSelect");
-  Check(reordered_hint(GameFunction::SelectShip6) == GameFunction::Max,
-        "Fleet beyond the eight supported mod shortcuts must not advertise a shortcut");
-  Check(MapKey::GetShortcutHint(ship_hint(GameFunction::SelectShip7)).empty(),
-        "Unbound ship selection must not advertise a working shortcut");
-  MapKey::AddMappedKey(GameFunction::SelectShip6, MapKey::Parse("CTRL-F8"));
-  MapKey::CacheShortcutHints();
-  Check(MapKey::GetShortcutHint(ship_hint(GameFunction::SelectShip7)) == "^F8",
-        "Gapped ship hint must use the actual custom binding, not a hardcoded number");
-
-  constexpr auto toggle = GameFunction::ToggleShortcutHints;
-  constexpr auto galaxy = GameFunction::ShowGalaxy;
-  Check(!MapKey::HasBinding(toggle), "Absent binding must not enable hints");
-
-  // Match config registration: only keys with a primary key are accepted.
-  for (const auto* text : {"NONE", "", "INVALID", "CTRL"}) {
-    auto parsed = MapKey::Parse(text);
-    Check(parsed.Key == KeyCode::None, "Disabled/invalid binding acquired a key");
-    if (parsed.Key != KeyCode::None) MapKey::AddMappedKey(toggle, std::move(parsed));
-    Check(!MapKey::HasBinding(toggle), "Disabled/invalid binding enabled hints");
-  }
-
-  MapKey::AddMappedKey(galaxy, MapKey::Parse("CTRL-G"));
-  MapKey::AddMappedKey(galaxy, MapKey::Parse("F8"));
-  Check(MapKey::GetShortcutHint(galaxy).empty(), "Parsing must not populate hint cache");
-  Check(MapKey::GetShortcuts(galaxy) == "CTRL-G | F8", "Normal shortcut labels changed");
-
-  // The toggle may be parsed after bindings whose badges it enables.
-  MapKey::AddMappedKey(toggle, MapKey::Parse("SHIFT-F7"));
-  Check(MapKey::HasBinding(toggle), "Valid chord must enable hints");
-  Check(MapKey::GetShortcutHint(toggle).empty(), "Binding registration must not populate hint cache");
-  Check(MapKey::GetShortcutHint(galaxy).empty(), "Registering toggle must not format earlier bindings");
-  MapKey::CacheShortcutHints();
-  Check(MapKey::GetShortcutHint(galaxy) == "^G", "Cache must include earlier binding, first alternative only");
-  Check(MapKey::GetShortcutHint(toggle) == "+F7", "Toggle badge missing");
-  Check(MapKey::GetShortcutHint(GameFunction::ShowResearch).empty(), "Unbound action acquired a badge");
-  MapKey::CacheShortcutHints();
-  Check(MapKey::GetShortcutHint(galaxy) == "^G", "Repeated cache preparation changed label");
-  // Pan uses the production shortcut matcher: both default alternatives work,
-  // but adding a modifier must not also match the unmodified movement action.
-  for (const auto [action, defaults] : {
-           std::pair{GameFunction::MoveUp, DefaultConfig::Shortcuts::move_up},
-           std::pair{GameFunction::MoveDown, DefaultConfig::Shortcuts::move_down},
-           std::pair{GameFunction::MoveLeft, DefaultConfig::Shortcuts::move_left},
-           std::pair{GameFunction::MoveRight, DefaultConfig::Shortcuts::move_right}}) {
-    std::string_view remaining = defaults;
-    while (!remaining.empty()) {
-      auto end = remaining.find('|');
-      auto binding = MapKey::Parse(std::string(remaining.substr(0, end)));
-      Check(binding.Key != KeyCode::None, "Invalid movement default");
-      MapKey::AddMappedKey(action, binding);
-      held[static_cast<int>(binding.Key)] = true;
-      Check(MapKey::IsPressed(action), "Default movement key did not match");
-      for (auto modifier : {KeyCode::LeftControl, KeyCode::RightControl, KeyCode::LeftShift,
-                             KeyCode::LeftAlt, KeyCode::LeftCommand}) {
-        held[static_cast<int>(modifier)] = true;
-        Check(!MapKey::IsPressed(action), "Modified chord leaked into plain movement");
-        held[static_cast<int>(modifier)] = false;
-      }
-      held[static_cast<int>(binding.Key)] = false;
-      Check(!MapKey::IsPressed(action), "Released movement key remained active");
-      if (end == std::string_view::npos) break;
-      remaining.remove_prefix(end + 1);
-    }
-  }
-  // A modified movement binding must not claim its own direction. Non-movement
-  // actions still claim it, preserving the existing hold-until-release guard.
-  MapKey::AddMappedKey(GameFunction::MoveDown, MapKey::Parse("CTRL-DOWN"));
-  held[static_cast<int>(KeyCode::LeftControl)] = true;
-  held[static_cast<int>(KeyCode::DownArrow)] = true;
-  claimed = KeyCode::None;
-  Check(MapKey::IsDown(GameFunction::MoveDown) && MapKey::IsPressed(GameFunction::MoveDown),
-        "Explicit movement chord did not match");
-  Check(claimed == KeyCode::None, "Movement claimed and blocked itself");
-  MapKey::AddMappedKey(toggle, MapKey::Parse("CTRL-DOWN"));
-  Check(MapKey::IsDown(toggle) && claimed == KeyCode::DownArrow, "Other chord lost directional ownership");
-  held.fill(false);
-  std::cout << "Shortcut hint and movement binding tests passed\n";
-
-}
diff --git a/win-proxy-dll/src/main.cc b/win-proxy-dll/src/main.cc
index f4c0e0765..88ca1daf4 100644
--- a/win-proxy-dll/src/main.cc
+++ b/win-proxy-dll/src/main.cc
@@ -1,50 +1,22 @@
-#include <Windows.h>
+// The Windows entry point: the game loads this as version.dll from its folder.
 
-#include <filesystem>
+#include <Windows.h>
 
-#include "patches/patches.h"
+#include <string_view>
 
-void VersionDllInit();
+#include "mod.h"
 
-BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID /*lpReserved*/)
+BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID)
 {
-  std::filesystem::path game_path;
-
-  switch (fdwReason) {
-    case DLL_PROCESS_ATTACH:
-      DisableThreadLibraryCalls(hinstDLL);
-
-      TCHAR szFileName[MAX_PATH];
-      GetModuleFileName(NULL, szFileName, MAX_PATH);
-
-      game_path = szFileName;
-
-      if (!game_path.filename().generic_wstring().starts_with(L"prime")) {
-        return TRUE;
-      }
-
-      // Since we are replacing version.dll, need the proper forwards
-      VersionDllInit();
-      ApplyPatches();
-      break;
-    case DLL_THREAD_ATTACH:
-      break;
-    case DLL_THREAD_DETACH:
-      break;
-    case DLL_PROCESS_DETACH:
-      break;
-  }
+  if (reason != DLL_PROCESS_ATTACH)
+    return TRUE;
+  DisableThreadLibraryCalls(instance);
+
+  // Other processes that load version.dll from the game folder only get the forwards in version.cc.
+  wchar_t    path[MAX_PATH];
+  const auto length = GetModuleFileNameW(nullptr, path, MAX_PATH);
+  const auto exe    = std::wstring_view(path, length);
+  if (exe.substr(exe.find_last_of(L"\\/") + 1).starts_with(L"prime"))
+    StartMod();
   return TRUE;
 }
-
-void* operator new[](size_t size, const char* /*name*/, int /*flags*/, unsigned /*debugFlags*/, const char* /*file*/,
-                     int /*line*/)
-{
-  return malloc(size);
-}
-
-void* operator new[](size_t size, size_t /*alignment*/, size_t /*alignmentOffset*/, const char* /*name*/, int /*flags*/,
-                     unsigned /*debugFlags*/, const char* /*file*/, int /*line*/)
-{
-  return malloc(size);
-}
diff --git a/win-proxy-dll/src/version.cc b/win-proxy-dll/src/version.cc
index 88cfc2c83..de298ab9e 100644
--- a/win-proxy-dll/src/version.cc
+++ b/win-proxy-dll/src/version.cc
@@ -1,198 +1,89 @@
+// The version.dll exports the game imports, forwarded to the system copy. Loading the mod as version.dll from the
+// game folder is what injects it; every other process that picks this file up must still get working calls.
+
 #include <Windows.h>
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_VerFindFileA)(DWORD, LPCSTR, LPCSTR, LPCSTR, LPSTR, PUINT, LPSTR, PUINT);
-ORIG_FUNCTION_VerFindFileA orig_VerFindFileA;
-DWORD
-APIENTRY
-VerFindFileA(_In_ DWORD uFlags, _In_ LPCSTR szFileName, _In_opt_ LPCSTR szWinDir, _In_ LPCSTR szAppDir,
-             _Out_writes_(*puCurDirLen) LPSTR szCurDir, _Inout_ PUINT puCurDirLen,
-             _Out_writes_(*puDestDirLen) LPSTR szDestDir, _Inout_ PUINT puDestDirLen)
-{
-  return (orig_VerFindFileA)(uFlags, szFileName, szWinDir, szAppDir, szCurDir, puCurDirLen, szDestDir, puDestDirLen);
-}
+#include <string>
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_VerFindFileW)(DWORD, LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, PUINT, LPWSTR, PUINT);
-ORIG_FUNCTION_VerFindFileW orig_VerFindFileW;
-DWORD
-APIENTRY
-VerFindFileW(_In_ DWORD uFlags, _In_ LPCWSTR szFileName, _In_opt_ LPCWSTR szWinDir, _In_ LPCWSTR szAppDir,
-             _Out_writes_(*puCurDirLen) LPWSTR szCurDir, _Inout_ PUINT puCurDirLen,
-             _Out_writes_(*puDestDirLen) LPWSTR szDestDir, _Inout_ PUINT puDestDirLen)
+namespace
 {
-  return (orig_VerFindFileW)(uFlags, szFileName, szWinDir, szAppDir, szCurDir, puCurDirLen, szDestDir, puDestDirLen);
-}
-
-typedef DWORD(WINAPI *ORIG_FUNCTION_VerInstallFileA)(DWORD, LPCSTR, LPCSTR, LPCSTR, LPCSTR, LPCSTR, LPSTR, PUINT);
-ORIG_FUNCTION_VerInstallFileA orig_VerInstallFileA;
-DWORD
-APIENTRY
-VerInstallFileA(_In_ DWORD uFlags, _In_ LPCSTR szSrcFileName, _In_ LPCSTR szDestFileName, _In_ LPCSTR szSrcDir,
-                _In_ LPCSTR szDestDir, _In_ LPCSTR szCurDir, _Out_writes_(*puTmpFileLen) LPSTR szTmpFile,
-                _Inout_ PUINT puTmpFileLen)
+// Loaded on the first forwarded call rather than in DllMain, which runs under the loader lock.
+HMODULE SystemVersionDll()
 {
-  return (orig_VerInstallFileA)(uFlags, szSrcFileName, szDestFileName, szSrcDir, szDestDir, szCurDir, szTmpFile,
-                                puTmpFileLen);
+  static const HMODULE module = [] {
+    wchar_t    dir[MAX_PATH];
+    const auto length = GetSystemDirectoryW(dir, MAX_PATH);
+    if (length == 0 || length >= MAX_PATH)
+      return HMODULE{};
+    return LoadLibraryW((std::wstring(dir, length) + L"\\version.dll").c_str());
+  }();
+  return module;
 }
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_VerInstallFileW)(DWORD, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, PUINT);
-ORIG_FUNCTION_VerInstallFileW orig_VerInstallFileW;
-DWORD
-APIENTRY
-VerInstallFileW(_In_ DWORD uFlags, _In_ LPCWSTR szSrcFileName, _In_ LPCWSTR szDestFileName, _In_ LPCWSTR szSrcDir,
-                _In_ LPCWSTR szDestDir, _In_ LPCWSTR szCurDir, _Out_writes_(*puTmpFileLen) LPWSTR szTmpFile,
-                _Inout_ PUINT puTmpFileLen)
+FARPROC Resolve(const char* name)
 {
-  return (orig_VerInstallFileW)(uFlags, szSrcFileName, szDestFileName, szSrcDir, szDestDir, szCurDir, szTmpFile,
-                                puTmpFileLen);
+  auto* module = SystemVersionDll();
+  return module ? GetProcAddress(module, name) : nullptr;
 }
+} // namespace
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_GetFileVersionInfoSizeA)(LPCSTR, LPDWORD);
-ORIG_FUNCTION_GetFileVersionInfoSizeA orig_GetFileVersionInfoSizeA;
-DWORD
-APIENTRY
-GetFileVersionInfoSizeA(_In_ LPCSTR       lptstrFilename, /* Filename of version stamped file */
-                        _Out_opt_ LPDWORD lpdwHandle      /* Information for use by GetFileVersionInfo */
-)
-{
-  return (orig_GetFileVersionInfoSizeA)(lptstrFilename, lpdwHandle);
-}
+// Every export returns DWORD or BOOL, where 0 is failure.
+#define FORWARD(name, ...)                                                                                             \
+  static const auto original = reinterpret_cast<decltype(&::name)>(Resolve(#name));                                    \
+  if (!original) {                                                                                                     \
+    SetLastError(ERROR_PROC_NOT_FOUND);                                                                                \
+    return 0;                                                                                                          \
+  }                                                                                                                    \
+  return original(__VA_ARGS__)
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_GetFileVersionInfoSizeW)(LPCWSTR, LPDWORD);
-ORIG_FUNCTION_GetFileVersionInfoSizeW orig_GetFileVersionInfoSizeW;
-DWORD
-APIENTRY
-GetFileVersionInfoSizeW(_In_ LPCWSTR      lptstrFilename, /* Filename of version stamped file */
-                        _Out_opt_ LPDWORD lpdwHandle      /* Information for use by GetFileVersionInfo */
-)
-{
-  return (orig_GetFileVersionInfoSizeW)(lptstrFilename, lpdwHandle);
-}
+DWORD APIENTRY VerFindFileA(DWORD flags, LPCSTR file, LPCSTR win_dir, LPCSTR app_dir, LPSTR cur_dir, PUINT cur_dir_len,
+                            LPSTR dest_dir, PUINT dest_dir_len)
+{ FORWARD(VerFindFileA, flags, file, win_dir, app_dir, cur_dir, cur_dir_len, dest_dir, dest_dir_len); }
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_GetFileVersionInfoA)(LPCSTR, DWORD, DWORD, LPVOID);
-ORIG_FUNCTION_GetFileVersionInfoA orig_GetFileVersionInfoA;
-BOOL APIENTRY                     GetFileVersionInfoA(_In_ LPCSTR      lptstrFilename, /* Filename of version stamped file */
-                                                      _Reserved_ DWORD dwHandle, /* Information from GetFileVersionSize */
-                                                      _In_ DWORD       dwLen,    /* Length of buffer for info */
-                                                      _Out_writes_bytes_(dwLen) LPVOID lpData /* Buffer to place the data structure */
-                    )
-{
-  return (orig_GetFileVersionInfoA)(lptstrFilename, dwHandle, dwLen, lpData);
-}
+DWORD APIENTRY VerFindFileW(DWORD flags, LPCWSTR file, LPCWSTR win_dir, LPCWSTR app_dir, LPWSTR cur_dir,
+                            PUINT cur_dir_len, LPWSTR dest_dir, PUINT dest_dir_len)
+{ FORWARD(VerFindFileW, flags, file, win_dir, app_dir, cur_dir, cur_dir_len, dest_dir, dest_dir_len); }
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_GetFileVersionInfoW)(LPCWSTR, DWORD, DWORD, LPVOID);
-ORIG_FUNCTION_GetFileVersionInfoW orig_GetFileVersionInfoW;
-BOOL APIENTRY GetFileVersionInfoW(_In_ LPCWSTR     lptstrFilename,        /* Filename of version stamped file */
-                                  _Reserved_ DWORD dwHandle,              /* Information from GetFileVersionSize */
-                                  _In_ DWORD       dwLen,                 /* Length of buffer for info */
-                                  _Out_writes_bytes_(dwLen) LPVOID lpData /* Buffer to place the data structure */
-)
-{
-  return (orig_GetFileVersionInfoW)(lptstrFilename, dwHandle, dwLen, lpData);
-}
+DWORD APIENTRY VerInstallFileA(DWORD flags, LPCSTR src_file, LPCSTR dest_file, LPCSTR src_dir, LPCSTR dest_dir,
+                               LPCSTR cur_dir, LPSTR tmp_file, PUINT tmp_file_len)
+{ FORWARD(VerInstallFileA, flags, src_file, dest_file, src_dir, dest_dir, cur_dir, tmp_file, tmp_file_len); }
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_GetFileVersionInfoSizeExA)(DWORD, LPCSTR, LPDWORD);
-ORIG_FUNCTION_GetFileVersionInfoSizeExA orig_GetFileVersionInfoSizeExA;
-DWORD APIENTRY GetFileVersionInfoSizeExA(_In_ DWORD dwFlags, _In_ LPCSTR lpwstrFilename, _Out_ LPDWORD lpdwHandle)
-{
-  return (orig_GetFileVersionInfoSizeExA)(dwFlags, lpwstrFilename, lpdwHandle);
-}
+DWORD APIENTRY VerInstallFileW(DWORD flags, LPCWSTR src_file, LPCWSTR dest_file, LPCWSTR src_dir, LPCWSTR dest_dir,
+                               LPCWSTR cur_dir, LPWSTR tmp_file, PUINT tmp_file_len)
+{ FORWARD(VerInstallFileW, flags, src_file, dest_file, src_dir, dest_dir, cur_dir, tmp_file, tmp_file_len); }
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_GetFileVersionInfoSizeExW)(DWORD, LPCWSTR, LPDWORD);
-ORIG_FUNCTION_GetFileVersionInfoSizeExW orig_GetFileVersionInfoSizeExW;
-DWORD APIENTRY GetFileVersionInfoSizeExW(_In_ DWORD dwFlags, _In_ LPCWSTR lpwstrFilename, _Out_ LPDWORD lpdwHandle)
-{
-  return (orig_GetFileVersionInfoSizeExW)(dwFlags, lpwstrFilename, lpdwHandle);
-}
+DWORD APIENTRY GetFileVersionInfoSizeA(LPCSTR file, LPDWORD handle)
+{ FORWARD(GetFileVersionInfoSizeA, file, handle); }
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_GetFileVersionInfoExA)(DWORD, LPCSTR, DWORD, DWORD, LPVOID);
-ORIG_FUNCTION_GetFileVersionInfoExA orig_GetFileVersionInfoExA;
-BOOL APIENTRY GetFileVersionInfoExA(_In_ DWORD dwFlags, _In_ LPCSTR lpwstrFilename, _Reserved_ DWORD dwHandle,
-                                    _In_ DWORD dwLen, _Out_writes_bytes_(dwLen) LPVOID lpData)
-{
-  return (orig_GetFileVersionInfoExA)(dwFlags, lpwstrFilename, dwHandle, dwLen, lpData);
-}
+DWORD APIENTRY GetFileVersionInfoSizeW(LPCWSTR file, LPDWORD handle)
+{ FORWARD(GetFileVersionInfoSizeW, file, handle); }
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_GetFileVersionInfoExW)(DWORD, LPCWSTR, DWORD, DWORD, LPVOID);
-ORIG_FUNCTION_GetFileVersionInfoExW orig_GetFileVersionInfoExW;
-BOOL APIENTRY GetFileVersionInfoExW(_In_ DWORD dwFlags, _In_ LPCWSTR lpwstrFilename, _Reserved_ DWORD dwHandle,
-                                    _In_ DWORD dwLen, _Out_writes_bytes_(dwLen) LPVOID lpData)
-{
-  return (orig_GetFileVersionInfoExW)(dwFlags, lpwstrFilename, dwHandle, dwLen, lpData);
-}
+BOOL APIENTRY GetFileVersionInfoA(LPCSTR file, DWORD handle, DWORD length, LPVOID data)
+{ FORWARD(GetFileVersionInfoA, file, handle, length, data); }
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_VerLanguageNameA)(DWORD, LPSTR, DWORD);
-ORIG_FUNCTION_VerLanguageNameA orig_VerLanguageNameA;
-DWORD
-APIENTRY
-VerLanguageNameA(_In_ DWORD wLang, _Out_writes_(cchLang) LPSTR szLang, _In_ DWORD cchLang)
-{
-  return (orig_VerLanguageNameA)(wLang, szLang, cchLang);
-}
+BOOL APIENTRY GetFileVersionInfoW(LPCWSTR file, DWORD handle, DWORD length, LPVOID data)
+{ FORWARD(GetFileVersionInfoW, file, handle, length, data); }
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_VerLanguageNameW)(DWORD, LPWSTR, DWORD);
-ORIG_FUNCTION_VerLanguageNameW orig_VerLanguageNameW;
-DWORD
-APIENTRY
-VerLanguageNameW(_In_ DWORD wLang, _Out_writes_(cchLang) LPWSTR szLang, _In_ DWORD cchLang)
-{
-  return (orig_VerLanguageNameW)(wLang, szLang, cchLang);
-}
+DWORD APIENTRY GetFileVersionInfoSizeExA(DWORD flags, LPCSTR file, LPDWORD handle)
+{ FORWARD(GetFileVersionInfoSizeExA, flags, file, handle); }
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_VerQueryValueA)(LPCVOID, LPCSTR, LPVOID *, PUINT);
-ORIG_FUNCTION_VerQueryValueA orig_VerQueryValueA;
-BOOL APIENTRY                VerQueryValueA(_In_ LPCVOID pBlock, _In_ LPCSTR lpSubBlock,
-                                            _Outptr_result_buffer_(_Inexpressible_("buffer can be PWSTR or DWORD*"))
-                                                LPVOID *lplpBuffer,
-                                            _Out_ PUINT puLen)
-{
-  return (orig_VerQueryValueA)(pBlock, lpSubBlock, lplpBuffer, puLen);
-}
+DWORD APIENTRY GetFileVersionInfoSizeExW(DWORD flags, LPCWSTR file, LPDWORD handle)
+{ FORWARD(GetFileVersionInfoSizeExW, flags, file, handle); }
 
-typedef DWORD(WINAPI *ORIG_FUNCTION_VerQueryValueW)(LPCVOID, LPCWSTR, LPVOID *, PUINT);
-ORIG_FUNCTION_VerQueryValueW orig_VerQueryValueW;
-BOOL APIENTRY                VerQueryValueW(_In_ LPCVOID pBlock, _In_ LPCWSTR lpSubBlock,
-                                            _Outptr_result_buffer_(_Inexpressible_("buffer can be PWSTR or DWORD*"))
-                                                LPVOID *lplpBuffer,
-                                            _Out_ PUINT puLen)
-{
-  return (orig_VerQueryValueW)(pBlock, lpSubBlock, lplpBuffer, puLen);
-}
+BOOL APIENTRY GetFileVersionInfoExA(DWORD flags, LPCSTR file, DWORD handle, DWORD length, LPVOID data)
+{ FORWARD(GetFileVersionInfoExA, flags, file, handle, length, data); }
 
-typedef void(WINAPI *ORIG_FUNCTION_GetFileVersionInfoByHandle)();
-ORIG_FUNCTION_GetFileVersionInfoByHandle orig_GetFileVersionInfoByHandle;
-void WINAPI                              GetFileVersionInfoByHandle()
-{
-  (orig_GetFileVersionInfoByHandle)();
-}
+BOOL APIENTRY GetFileVersionInfoExW(DWORD flags, LPCWSTR file, DWORD handle, DWORD length, LPVOID data)
+{ FORWARD(GetFileVersionInfoExW, flags, file, handle, length, data); }
 
-void VersionDllInit()
-{
-  HMODULE hOriginalDll = LoadLibraryW(L"C:\\Windows\\system32\\version.dll");
-  if (!hOriginalDll) {
-    return;
-  }
-  orig_VerFindFileA        = (ORIG_FUNCTION_VerFindFileA)GetProcAddress(hOriginalDll, "VerFindFileA");
-  orig_VerFindFileW        = (ORIG_FUNCTION_VerFindFileW)GetProcAddress(hOriginalDll, "VerFindFileW");
-  orig_VerInstallFileA     = (ORIG_FUNCTION_VerInstallFileA)GetProcAddress(hOriginalDll, "VerInstallFileA");
-  orig_VerInstallFileW     = (ORIG_FUNCTION_VerInstallFileW)GetProcAddress(hOriginalDll, "VerInstallFileW");
-  orig_GetFileVersionInfoA = (ORIG_FUNCTION_GetFileVersionInfoA)GetProcAddress(hOriginalDll, "GetFileVersionInfoA");
-  orig_GetFileVersionInfoW = (ORIG_FUNCTION_GetFileVersionInfoW)GetProcAddress(hOriginalDll, "GetFileVersionInfoW");
-  orig_GetFileVersionInfoSizeA =
-      (ORIG_FUNCTION_GetFileVersionInfoSizeA)GetProcAddress(hOriginalDll, "GetFileVersionInfoSizeA");
-  orig_GetFileVersionInfoSizeW =
-      (ORIG_FUNCTION_GetFileVersionInfoSizeW)GetProcAddress(hOriginalDll, "GetFileVersionInfoSizeW");
-  orig_GetFileVersionInfoExA =
-      (ORIG_FUNCTION_GetFileVersionInfoExA)GetProcAddress(hOriginalDll, "GetFileVersionInfoExA");
-  orig_GetFileVersionInfoExW =
-      (ORIG_FUNCTION_GetFileVersionInfoExW)GetProcAddress(hOriginalDll, "GetFileVersionInfoExW");
-  orig_GetFileVersionInfoSizeExA =
-      (ORIG_FUNCTION_GetFileVersionInfoSizeExA)GetProcAddress(hOriginalDll, "GetFileVersionInfoSizeExA");
-  orig_GetFileVersionInfoSizeExW =
-      (ORIG_FUNCTION_GetFileVersionInfoSizeExW)GetProcAddress(hOriginalDll, "GetFileVersionInfoSizeExW");
-  orig_VerLanguageNameA = (ORIG_FUNCTION_VerLanguageNameA)GetProcAddress(hOriginalDll, "VerLanguageNameA");
-  orig_VerLanguageNameW = (ORIG_FUNCTION_VerLanguageNameW)GetProcAddress(hOriginalDll, "VerLanguageNameW");
-  orig_VerQueryValueA   = (ORIG_FUNCTION_VerQueryValueA)GetProcAddress(hOriginalDll, "VerQueryValueA");
-  orig_VerQueryValueW   = (ORIG_FUNCTION_VerQueryValueW)GetProcAddress(hOriginalDll, "VerQueryValueW");
-  orig_GetFileVersionInfoByHandle =
-      (ORIG_FUNCTION_GetFileVersionInfoByHandle)GetProcAddress(hOriginalDll, "GetFileVersionInfoByHandle");
-}
+DWORD APIENTRY VerLanguageNameA(DWORD language, LPSTR name, DWORD length)
+{ FORWARD(VerLanguageNameA, language, name, length); }
+
+DWORD APIENTRY VerLanguageNameW(DWORD language, LPWSTR name, DWORD length)
+{ FORWARD(VerLanguageNameW, language, name, length); }
+
+BOOL APIENTRY VerQueryValueA(LPCVOID block, LPCSTR sub_block, LPVOID* buffer, PUINT length)
+{ FORWARD(VerQueryValueA, block, sub_block, buffer, length); }
+
+BOOL APIENTRY VerQueryValueW(LPCVOID block, LPCWSTR sub_block, LPVOID* buffer, PUINT length)
+{ FORWARD(VerQueryValueW, block, sub_block, buffer, length); }
diff --git a/win-proxy-dll/src/version.def b/win-proxy-dll/src/version.def
index 05330bd72..386a56e7d 100644
--- a/win-proxy-dll/src/version.def
+++ b/win-proxy-dll/src/version.def
@@ -8,7 +8,6 @@ VerInstallFileW
 GetFileVersionInfoSizeA
 GetFileVersionInfoSizeW
 GetFileVersionInfoA
-GetFileInformationByHandle
 GetFileVersionInfoW
 GetFileVersionInfoSizeExA
 GetFileVersionInfoSizeExW
@@ -17,4 +16,4 @@ GetFileVersionInfoExW
 VerLanguageNameA
 VerLanguageNameW
 VerQueryValueA
-VerQueryValueW
\ No newline at end of file
+VerQueryValueW
diff --git a/xmake.lua b/xmake.lua
index dc452fa2e..8ff4f35a4 100644
--- a/xmake.lua
+++ b/xmake.lua
@@ -26,6 +26,7 @@ add_rules("mode.releasedbg")
 includes("xmake/rules/protobuf_sccache.lua")
 includes("xmake/rules/cxx_sccache.lua")
 includes("libs/il2cpp")
+includes("libs/unity")
 includes("mods")
 
 
@@ -33,7 +34,8 @@ target("il2cpp-bindings-tests")
     set_kind("binary")
     set_default(false)
     set_exceptions("cxx")
-    add_files("tests/il2cpp_bindings.cc")
+    add_files("tests/il2cpp_bindings.cc", "libs/unity/src/input.cc")
+    add_includedirs("libs/unity/include")
     add_deps("il2cpp")
 
 target("il2cpp-gc-tests")
@@ -51,9 +53,10 @@ if is_arch("x64", "x86_64") then
         add_packages("spud")
 end
 
--- Pure startup gate regression tests; no game process required.
-target("chat-startup-tests")
+target("mod-logic-tests")
     set_kind("binary")
     set_default(false)
-    add_files("tests/chat_startup.cc")
-    add_includedirs("mods/src")
+    set_exceptions("cxx")
+    add_files("tests/mod_logic.cc", "mods/src/patches/shortcuts.cc")
+    add_includedirs("mods/src", "libs/il2cpp/include", "third_party/libil2cpp", "libs/unity/include")
+    add_packages("spdlog", "toml++")
diff --git a/xmake/dependencies/common.lua b/xmake/dependencies/common.lua
index 74702f1be..e0fd89675 100644
--- a/xmake/dependencies/common.lua
+++ b/xmake/dependencies/common.lua
@@ -22,7 +22,6 @@ add_requires("protobuf 35.1")
 add_requires("cpr", {system = false})
 add_requires("spud v0.2.0-7")
 add_requires("libil2cpp")
-add_requires("simdutf", {system = false})
 
 add_requireconfs("cpr.libcurl.zlib", {
     system = false,