diff --git a/.clang-format b/.clang-format
index e051c2692a..4a24aec430 100644
--- a/.clang-format
+++ b/.clang-format
@@ -24,7 +24,7 @@ AlignConsecutiveBitFields:
   AcrossEmptyLines: false
   AcrossComments: false
 AllowShortLambdasOnASingleLine: All
-AllowShortBlocksOnASingleLine: Always
+AllowShortBlocksOnASingleLine: Empty
 AllowShortIfStatementsOnASingleLine: AllIfsAndElse
 AllowShortLoopsOnASingleLine: true
 AlwaysBreakAfterDefinitionReturnType: None
diff --git a/src/ll/api/Config.h b/src/ll/api/Config.h
index be5f0f8e41..cd0dda0f4d 100644
--- a/src/ll/api/Config.h
+++ b/src/ll/api/Config.h
@@ -56,8 +56,12 @@ inline bool loadConfig(T& config, std::string_view path, bool overwriteAfterFail
         } else {
             res = false;
         }
-    } catch (...) { res = false; }
-    if (!res && overwriteAfterFail) { saveConfig<T, J>(config, path); }
+    } catch (...) {
+        res = false;
+    }
+    if (!res && overwriteAfterFail) {
+        saveConfig<T, J>(config, path);
+    }
     return res;
 }
 
diff --git a/src/ll/api/Logger.cpp b/src/ll/api/Logger.cpp
index 8d3899b4ae..3b335ae6f7 100644
--- a/src/ll/api/Logger.cpp
+++ b/src/ll/api/Logger.cpp
@@ -33,7 +33,9 @@ void Logger::OutputStream::print(std::string_view s) const noexcept {
                 applyTextStyle(style[2], fmt::format(fmt::runtime(consoleFormat[3]), logger->title)),
                 applyTextStyle(style[3], fmt::format(fmt::runtime(consoleFormat[4]), replaceMcToAnsiCode(s)))
             );
-            if (!ll::globalConfig.logger.colorLog) { str = removeEscapeCode(str); }
+            if (!ll::globalConfig.logger.colorLog) {
+                str = removeEscapeCode(str);
+            }
             fmt::print("{}\r\n", str);
         }
         if (logger->getFile().is_open() && checkLogLevel(logger->fileLevel, level)) {
@@ -113,8 +115,7 @@ Logger::Logger(std::string_view title)
           fmt::fg(fmt::color::light_sea_green),
           {},
           {},
-      }
-  }),
+      }}),
   warn(OutputStream{
       *this,
       "WARN",
@@ -124,8 +125,7 @@ Logger::Logger(std::string_view title)
           fmt::fg(fmt::terminal_color::bright_yellow),
           fmt::fg(fmt::terminal_color::bright_yellow),
           fmt::fg(fmt::terminal_color::bright_yellow) | fmt::emphasis::bold,
-      }
-  }),
+      }}),
   error(OutputStream{
       *this,
       "ERROR",
@@ -135,8 +135,7 @@ Logger::Logger(std::string_view title)
           fmt::fg(fmt::terminal_color::bright_red),
           fmt::fg(fmt::terminal_color::bright_red),
           fmt::fg(fmt::terminal_color::bright_red) | fmt::emphasis::bold,
-      }
-  }),
+      }}),
   fatal(OutputStream{
       *this,
       "FATAL",
@@ -146,8 +145,7 @@ Logger::Logger(std::string_view title)
           fmt::fg(fmt::color::red),
           fmt::fg(fmt::color::red),
           fmt::fg(fmt::color::red) | fmt::emphasis::bold,
-      }
-  }) {}
+      }}) {}
 
 void Logger::resetFile() {
     if (ofs) {
@@ -159,7 +157,9 @@ void Logger::resetFile() {
 
 bool Logger::setFile(std::string const& logFile, bool appendMode) {
     resetFile();
-    if (logFile.empty()) { return true; }
+    if (logFile.empty()) {
+        return true;
+    }
 
     std::error_code ec;
     std::filesystem::create_directories(file_utils::u8path(logFile).remove_filename(), ec);
@@ -169,7 +169,9 @@ bool Logger::setFile(std::string const& logFile, bool appendMode) {
 
 bool Logger::setDefaultFile(std::string const& logFile, bool appendMode) {
     if (logFile.empty()) {
-        if (defaultFile.is_open()) { defaultFile.close(); }
+        if (defaultFile.is_open()) {
+            defaultFile.close();
+        }
         return true;
     }
 
diff --git a/src/ll/api/Logger.h b/src/ll/api/Logger.h
index 1d6d9bd5e4..eda76af4c2 100644
--- a/src/ll/api/Logger.h
+++ b/src/ll/api/Logger.h
@@ -110,7 +110,9 @@ class Logger {
     LLAPI static void setDefaultPlayerOutputFunc(PlayerOutputFunc const& func) { defaultPlayerOutputCallback = func; }
 
     std::ofstream& getFile() {
-        if (ofs) { return ofs.value(); }
+        if (ofs) {
+            return ofs.value();
+        }
         return defaultFile;
     }
 
diff --git a/src/ll/api/base/Base64.h b/src/ll/api/base/Base64.h
index 2bf87868bb..b6e3e76fec 100644
--- a/src/ll/api/base/Base64.h
+++ b/src/ll/api/base/Base64.h
@@ -17,7 +17,9 @@ inline size_t getEncodeLength(std::string const& str) { return getEncodeLength(s
 inline size_t getDecodeLength(std::string const& in) {
     uchar  count      = 0;
     size_t input_size = in.size();
-    for (auto it = in.rbegin(); *it == '='; ++it) { ++count; }
+    for (auto it = in.rbegin(); *it == '='; ++it) {
+        ++count;
+    }
     input_size -= count;     // remove padding size
     count       = 0;         // reset padding counter
     while (input_size % 4) { // redo padding
@@ -52,10 +54,14 @@ inline std::string encode(std::string const& text_input) {
         }
     }
 
-    if (j > -6) { result += base64Table[((i << 8) >> (j + 8)) & 0x3F]; }
+    if (j > -6) {
+        result += base64Table[((i << 8) >> (j + 8)) & 0x3F];
+    }
 
     // padding
-    while (result.size() % 4) { result.push_back('='); }
+    while (result.size() % 4) {
+        result.push_back('=');
+    }
 
     return result;
 }
diff --git a/src/ll/api/base/ErrorInfo.cpp b/src/ll/api/base/ErrorInfo.cpp
index fe328c84a2..811809461a 100644
--- a/src/ll/api/base/ErrorInfo.cpp
+++ b/src/ll/api/base/ErrorInfo.cpp
@@ -31,8 +31,12 @@ struct u8system_category : public std::_System_error_category {
         const std::_System_error_message msg(static_cast<ulong>(errCode));
         if (msg._Length) {
             std::string res{string_utils::str2str({msg._Str, msg._Length})};
-            if (res.ends_with('\n')) { res.pop_back(); }
-            if (res.ends_with('\r')) { res.pop_back(); }
+            if (res.ends_with('\n')) {
+                res.pop_back();
+            }
+            if (res.ends_with('\r')) {
+                res.pop_back();
+            }
             return string_utils::replaceAll(res, "\r\n", ", ");
         }
         return "unknown error";
@@ -70,8 +74,12 @@ struct ntstatus_category : public std::error_category {
         if (size) {
             std::string res{string_utils::wstr2str({msg, size})};
             LocalFree(msg);
-            if (res.ends_with('\n')) { res.pop_back(); }
-            if (res.ends_with('\r')) { res.pop_back(); }
+            if (res.ends_with('\n')) {
+                res.pop_back();
+            }
+            if (res.ends_with('\r')) {
+                res.pop_back();
+            }
             return string_utils::replaceAll(res, "\r\n", ", ");
         }
         return "unknown error";
@@ -162,13 +170,17 @@ static std::exception_ptr getNested(T const& e) {
 
     if constexpr (can_use_dynamic_cast) {
         const auto n = dynamic_cast<std::nested_exception const*>(std::addressof(e));
-        if (n) { return n->nested_ptr(); }
+        if (n) {
+            return n->nested_ptr();
+        }
     }
     return nullptr;
 }
 
 std::string makeExceptionString(std::exception_ptr ePtr) {
-    if (!ePtr) { throw std::bad_exception(); }
+    if (!ePtr) {
+        throw std::bad_exception();
+    }
 
     std::string res;
 
@@ -191,7 +203,7 @@ std::string makeExceptionString(std::exception_ptr ePtr) {
             }
             auto expTypeName = exc.getNumCatchableTypes() > 0 ? exc.getTypeInfo(0)->name() : "unknown exception";
             if (expTypeName == typeid(seh_exception).name()) {
-                res += fmt::format("Translated Seh Exception, from <{}>:\n", handleName);
+                res += fmt::format("Seh Exception, from <{}>:\n", handleName);
             } else {
                 res += fmt::format(
                     "C++ Exception: {}, from <{}>:\n",
@@ -218,7 +230,9 @@ std::string makeExceptionString(std::exception_ptr ePtr) {
     } catch (const std::exception& e) {
         res  += string_utils::tou8str(e.what());
         ePtr  = getNested(e);
-    } catch (const std::string& e) { res += string_utils::tou8str(e); } catch (char const* e) {
+    } catch (const std::string& e) {
+        res += string_utils::tou8str(e);
+    } catch (char const* e) {
         res += string_utils::tou8str(e);
     } catch (...) {
         auto unkExc  = current_exception();
@@ -245,7 +259,9 @@ void printCurrentException(optional_ref<ll::Logger> l, std::exception_ptr const&
     auto& rlogger = l.value_or(logger);
     try {
         auto res = makeExceptionString(e);
-        for (auto& sv : string_utils::splitByPattern(res, "\n")) { rlogger.error(sv); }
+        for (auto& sv : string_utils::splitByPattern(res, "\n")) {
+            rlogger.error(sv);
+        }
         return;
     } catch (...) {}
     rlogger.error("unknown error");
diff --git a/src/ll/api/base/KeyValueDB.cpp b/src/ll/api/base/KeyValueDB.cpp
index f9002c5144..a0d16a09d3 100644
--- a/src/ll/api/base/KeyValueDB.cpp
+++ b/src/ll/api/base/KeyValueDB.cpp
@@ -34,8 +34,12 @@ class KeyValueDB::KeyValueDBImpl {
         options.reuse_logs           = true; // @warning: experimental
         options.create_if_missing    = create;
 
-        if (cacheSize) { options.block_cache = leveldb::NewLRUCache(cacheSize); }
-        if (filterBit) { options.filter_policy = leveldb::NewBloomFilterPolicy(filterBit); }
+        if (cacheSize) {
+            options.block_cache = leveldb::NewLRUCache(cacheSize);
+        }
+        if (filterBit) {
+            options.filter_policy = leveldb::NewBloomFilterPolicy(filterBit);
+        }
 
         leveldb::DB* database = nullptr;
         status                = leveldb::DB::Open(options, path, &database);
@@ -52,7 +56,9 @@ class KeyValueDB::KeyValueDBImpl {
     [[nodiscard]] std::optional<std::string> get(std::string_view key) const {
         std::string result;
         auto        s = db->Get(readOptions, leveldb::Slice(key.data(), key.size()), &result);
-        if (!s.ok()) { return std::nullopt; }
+        if (!s.ok()) {
+            return std::nullopt;
+        }
         return result;
     }
 
@@ -79,7 +85,9 @@ class KeyValueDB::KeyValueDBImpl {
         for (it->SeekToFirst(); it->Valid(); it->Next()) {
             auto k = it->key();
             auto v = it->value();
-            if (!fn({k.data(), k.size()}, {v.data(), v.size()})) { break; }
+            if (!fn({k.data(), k.size()}, {v.data(), v.size()})) {
+                break;
+            }
         }
         delete it;
     }
diff --git a/src/ll/api/base/Version.h b/src/ll/api/base/Version.h
index 1d6e41c7ad..81df5abb4c 100644
--- a/src/ll/api/base/Version.h
+++ b/src/ll/api/base/Version.h
@@ -27,7 +27,9 @@ constexpr std::uint16_t to_digit(char c) noexcept { return static_cast<std::uint
 constexpr char const* from_chars(char const* first, char const* last, std::uint16_t& d) noexcept {
     if (first != last && is_digit(*first)) {
         std::int32_t t = 0;
-        for (; first != last && is_digit(*first); ++first) { t = t * 10 + to_digit(*first); }
+        for (; first != last && is_digit(*first); ++first) {
+            t = t * 10 + to_digit(*first);
+        }
         if (t <= (std::numeric_limits<std::uint16_t>::max)()) {
             d = static_cast<std::uint16_t>(t);
             return first;
@@ -39,7 +41,9 @@ constexpr char const* from_chars(char const* first, char const* last, std::uint1
 constexpr char const* from_chars(char const* first, char const* last, std::optional<std::uint16_t>& d) noexcept {
     if (first != last && is_digit(*first)) {
         std::int32_t t = 0;
-        for (; first != last && is_digit(*first); ++first) { t = t * 10 + to_digit(*first); }
+        for (; first != last && is_digit(*first); ++first) {
+            t = t * 10 + to_digit(*first);
+        }
         if (t <= (std::numeric_limits<std::uint16_t>::max)()) {
             d = static_cast<std::uint16_t>(t);
             return first;
@@ -96,7 +100,9 @@ struct PreRelease {
 
     constexpr detail::from_chars_result from_chars(char const* first, char const* last) noexcept {
         auto begin = first;
-        while (first != last && !detail::is_plus(*first)) { first++; }
+        while (first != last && !detail::is_plus(*first)) {
+            first++;
+        }
         std::string                   s{begin, first};
         std::vector<std::string_view> tokens;
         tokens = ll::utils::string_utils::splitByPattern(s, ".");
@@ -116,7 +122,9 @@ struct PreRelease {
     }
 
     constexpr PreRelease& from_string(std::string_view str) {
-        if (!from_string_noexcept(str)) { throw VersionParseError("Invalid version string."); }
+        if (!from_string_noexcept(str)) {
+            throw VersionParseError("Invalid version string.");
+        }
         return *this;
     }
 
@@ -130,7 +138,9 @@ struct PreRelease {
             }
             str += '.';
         }
-        if (str.ends_with('.')) { str.pop_back(); }
+        if (str.ends_with('.')) {
+            str.pop_back();
+        }
         return str;
     }
 };
@@ -181,8 +191,12 @@ struct Version {
         auto next = first;
         if (next = detail::from_chars(next, last, major); detail::check_delimiter(next, last, '.')) {
             if (next = detail::from_chars(++next, last, minor); detail::check_delimiter(next, last, '.')) {
-                if (next = detail::from_chars(++next, last, patch); next == last) { return {next, std::errc{}}; }
-                if (!next) { return {nullptr, std::errc::invalid_argument}; }
+                if (next = detail::from_chars(++next, last, patch); next == last) {
+                    return {next, std::errc{}};
+                }
+                if (!next) {
+                    return {nullptr, std::errc::invalid_argument};
+                }
                 if (detail::check_delimiter(next, last, '-')) {
                     PreRelease pre;
                     auto       result = pre.from_chars(++next, last);
@@ -190,11 +204,15 @@ struct Version {
                     if (pre.values.empty()) return {next, std::errc::invalid_argument};
                     preRelease = pre;
                     next       = result.ptr;
-                    if (result && next == last) { return {next, std::errc{}}; }
+                    if (result && next == last) {
+                        return {next, std::errc{}};
+                    }
                 }
                 if (detail::check_delimiter(next, last, '+')) {
                     build = {++next, static_cast<size_t>(last - next)};
-                    if (build->empty()) { return {nullptr, std::errc::invalid_argument}; }
+                    if (build->empty()) {
+                        return {nullptr, std::errc::invalid_argument};
+                    }
                     next = last;
                     if (std::any_of(build->begin(), build->end(), [](char c) {
                             return !detail::is_digit(c) && !detail::is_letter(c);
@@ -202,7 +220,9 @@ struct Version {
                         return {nullptr, std::errc::invalid_argument};
                     }
                 }
-                if (next == last) { return {next, std::errc{}}; }
+                if (next == last) {
+                    return {next, std::errc{}};
+                }
             }
         }
         return {first, std::errc::invalid_argument};
@@ -213,7 +233,9 @@ struct Version {
     }
 
     constexpr Version& from_string(std::string_view str) {
-        if (!from_string_noexcept(str)) { throw VersionParseError("Invalid version string."); }
+        if (!from_string_noexcept(str)) {
+            throw VersionParseError("Invalid version string.");
+        }
         return *this;
     }
 
@@ -232,11 +254,19 @@ struct Version {
     }
 
     [[nodiscard]] constexpr std::strong_ordering operator<=>(Version const& other) const noexcept {
-        if (major != other.major) { return major <=> other.major; }
-        if (minor != other.minor) { return minor <=> other.minor; }
-        if (patch != other.patch) { return patch <=> other.patch; }
+        if (major != other.major) {
+            return major <=> other.major;
+        }
+        if (minor != other.minor) {
+            return minor <=> other.minor;
+        }
+        if (patch != other.patch) {
+            return patch <=> other.patch;
+        }
         if (preRelease.has_value()) {
-            if (other.preRelease.has_value()) { return preRelease.value() <=> other.preRelease.value(); }
+            if (other.preRelease.has_value()) {
+                return preRelease.value() <=> other.preRelease.value();
+            }
             return std::strong_ordering::less;
         } else if (other.preRelease.has_value()) {
             return std::strong_ordering::greater;
@@ -259,7 +289,9 @@ inline J serialize(Version const& ver) {
 }
 template <class J>
 inline void deserialize(Version& ver, J const& j) {
-    if (j.is_string()) { ver.from_string(j.template get<std::string>()); }
+    if (j.is_string()) {
+        ver.from_string(j.template get<std::string>());
+    }
 }
 
 namespace literals {
diff --git a/src/ll/api/chrono/GameChrono.cpp b/src/ll/api/chrono/GameChrono.cpp
index bbe16e5309..22b0d9b425 100644
--- a/src/ll/api/chrono/GameChrono.cpp
+++ b/src/ll/api/chrono/GameChrono.cpp
@@ -18,7 +18,9 @@ LL_AUTO_TYPED_INSTANCE_HOOK(ServerClockTickHook, HookPriority::Normal, ServerLev
 }
 
 GameTimeClock::time_point GameTimeClock::now() noexcept {
-    if (!ll::Global<Level>) { return time_point::max(); }
+    if (!ll::Global<Level>) {
+        return time_point::max();
+    }
     return time_point(duration((int64)(ll::Global<Level>->getCurrentTick().t)));
 }
 
diff --git a/src/ll/api/command/DynamicCommand.cpp b/src/ll/api/command/DynamicCommand.cpp
index 75e0ce31fd..25a6a95a03 100644
--- a/src/ll/api/command/DynamicCommand.cpp
+++ b/src/ll/api/command/DynamicCommand.cpp
@@ -412,7 +412,9 @@ DynamicCommandInstance* DynamicCommand::preSetup(std::unique_ptr<class DynamicCo
 
     // Check if there is another command with the same name
     auto signature = ll::Global<CommandRegistry>->findCommand(name);
-    if (signature) { throw std::runtime_error("There is already a command named " + signature->name); }
+    if (signature) {
+        throw std::runtime_error("There is already a command named " + signature->name);
+    }
 
     try {
         if (!commandInstance) throw std::runtime_error("Command instance is null");
@@ -456,7 +458,9 @@ DynamicCommandInstance* DynamicCommand::preSetup(std::unique_ptr<class DynamicCo
                         namePtr->swap(fixedName);
                         fixedView = *namePtr;
                         for (auto& data : commandInstance->parameterDatas) {
-                            if (data.description == fixedName) { data.description = *namePtr; }
+                            if (data.description == fixedName) {
+                                data.description = *namePtr;
+                            }
                         }
                         break;
                     }
@@ -499,7 +503,9 @@ DynamicCommandInstance* DynamicCommand::preSetup(std::unique_ptr<class DynamicCo
         // commandInstance->overloads.clear();
         auto res = dynamicCommandInstances.emplace(commandInstance->name_, std::move(commandInstance));
         return res.first->second.get();
-    } catch (...) { OutputError(name); }
+    } catch (...) {
+        OutputError(name);
+    }
     return nullptr;
 }
 
@@ -528,15 +534,23 @@ DynamicCommand::~DynamicCommand() {
 
 void DynamicCommand::execute(CommandOrigin const& origin, CommandOutput& output) const {
     auto iter = dynamicCommandInstances.find(getCommandName());
-    if (iter == dynamicCommandInstances.end()) { return output.error("Dynamic Command Not Found"); }
+    if (iter == dynamicCommandInstances.end()) {
+        return output.error("Dynamic Command Not Found");
+    }
     auto& commandIns = *iter->second;
-    if (!commandIns.callback_) { return output.error(fmt::format("Command {} has been removed.", getCommandName())); }
+    if (!commandIns.callback_) {
+        return output.error(fmt::format("Command {} has been removed.", getCommandName()));
+    }
     try {
         std::unordered_map<std::string, Result> results;
 
-        for (auto& [name, param] : commandIns.parameterPtrs) { results.emplace(name, param.getResult(this, &origin)); }
+        for (auto& [name, param] : commandIns.parameterPtrs) {
+            results.emplace(name, param.getResult(this, &origin));
+        }
         commandIns.callback_(*this, origin, output, results);
-    } catch (...) { OutputError(getCommandName()); }
+    } catch (...) {
+        OutputError(getCommandName());
+    }
 }
 
 std::unique_ptr<class DynamicCommandInstance> DynamicCommand::createCommand(
@@ -571,10 +585,16 @@ std::unique_ptr<class DynamicCommandInstance> DynamicCommand::createCommand(
 ) {
     auto command = createCommand(name, description, permission, flag1, flag2);
     if (!command) return std::unique_ptr<class DynamicCommandInstance>();
-    for (auto& [desc, values] : enums) { command->setEnum(desc, std::move(values)); }
-    for (auto& param : params) { command->newParameter(std::move(param)); }
+    for (auto& [desc, values] : enums) {
+        command->setEnum(desc, std::move(values));
+    }
+    for (auto& param : params) {
+        command->newParameter(std::move(param));
+    }
     if (overloads.size() > 0) {
-        for (auto& overload : overloads) { command->addOverload(std::move(overload)); }
+        for (auto& overload : overloads) {
+            command->addOverload(std::move(overload));
+        }
     } else {
         command->addOverload();
     }
@@ -663,7 +683,9 @@ std::unique_ptr<DynamicCommandInstance> DynamicCommandInstance::create(
 
 bool DynamicCommandInstance::addOverload(std::vector<DynamicCommand::ParameterData>&& params) {
     std::vector<ParameterIndex> indices;
-    for (auto& param : params) { indices.push_back(newParameter(std::forward<ParameterData>(param))); }
+    for (auto& param : params) {
+        indices.push_back(newParameter(std::forward<ParameterData>(param)));
+    }
     return addOverload(std::move(indices));
 }
 
@@ -801,7 +823,9 @@ bool DynamicCommandInstance::addOverload(std::vector<char const*>&& params) {
     std::vector<ParameterIndex> paramIndices;
     for (auto& param : params) {
         auto index = findParameterIndex(param);
-        if (!index.isValid()) { throw std::runtime_error("Parameter " + std::string(param) + "not found"); }
+        if (!index.isValid()) {
+            throw std::runtime_error("Parameter " + std::string(param) + "not found");
+        }
         paramIndices.push_back(index);
     }
     return addOverload(std::move(paramIndices));
@@ -809,7 +833,9 @@ bool DynamicCommandInstance::addOverload(std::vector<char const*>&& params) {
 
 bool DynamicCommandInstance::addOverload(std::vector<std::string>&& params) {
     std::vector<ParameterIndex> paramIndices;
-    for (auto& param : params) { paramIndices.push_back(findParameterIndex(param)); }
+    for (auto& param : params) {
+        paramIndices.push_back(findParameterIndex(param));
+    }
     return addOverload(std::move(paramIndices));
 }
 
diff --git a/src/ll/api/command/DynamicCommand.h b/src/ll/api/command/DynamicCommand.h
index 8abf1cb787..bf615c46e4 100644
--- a/src/ll/api/command/DynamicCommand.h
+++ b/src/ll/api/command/DynamicCommand.h
@@ -308,13 +308,17 @@ class DynamicCommand : public Command {
                 return actors;
             }
             std::vector<Actor*> rtn;
-            for (auto& result : getRaw<CommandSelector<Actor>>().results(*origin)) { rtn.push_back(result); }
+            for (auto& result : getRaw<CommandSelector<Actor>>().results(*origin)) {
+                rtn.push_back(result);
+            }
             return rtn;
         }
         template <>
         std::vector<Player*> get<std::vector<Player*>>() const {
             std::vector<Player*> rtn;
-            for (auto& result : getRaw<CommandSelector<Player>>().results(*origin)) { rtn.push_back(result); }
+            for (auto& result : getRaw<CommandSelector<Player>>().results(*origin)) {
+                rtn.push_back(result);
+            }
             return rtn;
         }
         template <>
@@ -412,8 +416,7 @@ class DynamicCommand : public Command {
                 description == "" ? nullptr : description.data(),
                 (int)offset,
                 optional,
-                (int)offset + std::max(8, (int)sizeof(T))
-            };
+                (int)offset + std::max(8, (int)sizeof(T))};
             param.addOptions(option);
             return param;
         }
diff --git a/src/ll/api/event/EventBus.cpp b/src/ll/api/event/EventBus.cpp
index 4910a19533..9cfac3ec2c 100644
--- a/src/ll/api/event/EventBus.cpp
+++ b/src/ll/api/event/EventBus.cpp
@@ -81,7 +81,9 @@ class EventBus::EventBusImpl {
         if (auto i = streams.find(eventId); i != streams.end()) {
             auto& stream = i->second;
             if (stream.removeListener(listener)) {
-                if (stream.empty()) { streams.erase(i); }
+                if (stream.empty()) {
+                    streams.erase(i);
+                }
                 return true;
             }
         }
@@ -98,17 +100,25 @@ EventBus& EventBus::getInstance() {
 void EventBus::publish(Event& event, EventId const& eventId) {
     std::lock_guard lock(impl->mutex);
 
-    if (auto i = impl->streams.find(eventId); i != impl->streams.end()) { i->second.publish(event); }
+    if (auto i = impl->streams.find(eventId); i != impl->streams.end()) {
+        i->second.publish(event);
+    }
 }
 size_t EventBus::getListenerCount(EventId const& eventId) {
     std::lock_guard lock(impl->mutex);
-    if (auto i = impl->streams.find(eventId); i != impl->streams.end()) { return i->second.count(); }
+    if (auto i = impl->streams.find(eventId); i != impl->streams.end()) {
+        return i->second.count();
+    }
     return 0;
 }
 bool EventBus::addListener(ListenerPtr const& listener, EventId const& eventId, Canneller& canneller) {
-    if (!listener) { return false; }
+    if (!listener) {
+        return false;
+    }
     std::lock_guard lock(impl->mutex);
-    if (listener->getId() == 0) { listener->setId(impl->getNewListenerId()); }
+    if (listener->getId() == 0) {
+        listener->setId(impl->getNewListenerId());
+    }
     if (impl->addListener(listener, eventId)) {
         auto& info    = impl->listeners[listener->getId()];
         info.listener = listener;
@@ -119,12 +129,16 @@ bool EventBus::addListener(ListenerPtr const& listener, EventId const& eventId,
     return false;
 }
 bool EventBus::removeListener(ListenerPtr const& listener, EventId const& eventId, Canneller& canneller) {
-    if (!listener) { return false; }
+    if (!listener) {
+        return false;
+    }
     std::lock_guard lock(impl->mutex);
     auto&           watches = impl->listeners[listener->getId()].watches;
     bool            res     = false;
     if (eventId == EmptyEventId) {
-        for (auto& eid : watches) { res |= impl->removeListener(listener, eid); }
+        for (auto& eid : watches) {
+            res |= impl->removeListener(listener, eid);
+        }
         impl->listeners.erase(listener->getId());
         canneller.listeners.erase(listener->getId());
     } else {
@@ -140,15 +154,23 @@ bool EventBus::removeListener(ListenerPtr const& listener, EventId const& eventI
     return res;
 }
 ListenerPtr EventBus::getListener(ListenerId id) const {
-    if (id == 0) { return nullptr; }
+    if (id == 0) {
+        return nullptr;
+    }
     std::lock_guard lock(impl->mutex);
-    if (!impl->listeners.contains(id)) { return nullptr; }
+    if (!impl->listeners.contains(id)) {
+        return nullptr;
+    }
     return impl->listeners[id].listener.lock();
 }
 bool EventBus::hasListener(ListenerId id, EventId const& eventId) const {
-    if (id == 0) { return false; }
+    if (id == 0) {
+        return false;
+    }
     std::lock_guard lock(impl->mutex);
-    if (!impl->listeners.contains(id)) { return false; }
+    if (!impl->listeners.contains(id)) {
+        return false;
+    }
     if (eventId == EmptyEventId) {
         return true;
     } else {
diff --git a/src/ll/api/event/EventBus.h b/src/ll/api/event/EventBus.h
index 346df5145c..cf724f8984 100644
--- a/src/ll/api/event/EventBus.h
+++ b/src/ll/api/event/EventBus.h
@@ -23,7 +23,9 @@ class EventBus {
         Canneller() = default;
         ~Canneller() {
             auto list = listeners;
-            for (auto id : list) { EventBus::getInstance().removeListener(id); }
+            for (auto id : list) {
+                EventBus::getInstance().removeListener(id);
+            }
         }
 
     public:
@@ -82,7 +84,9 @@ class EventBus {
     template <std::derived_from<Event> T, std::derived_from<ListenerBase> L = Listener<T>, class... Args>
     inline auto emplaceListener(Args&&... args) {
         auto res = L::create(std::forward<Args>(args)...);
-        if (addListener<T>(res)) { T::tryRegisterHook(); }
+        if (addListener<T>(res)) {
+            T::tryRegisterHook();
+        }
         return res;
     }
 
@@ -103,12 +107,16 @@ class EventBus {
     LLNDAPI ListenerPtr getListener(ListenerId id) const;
 
     bool removeListener(ListenerId id) {
-        if (auto listener = getListener(id); listener) { return removeListener(listener, EmptyEventId); }
+        if (auto listener = getListener(id); listener) {
+            return removeListener(listener, EmptyEventId);
+        }
         return false;
     }
     template <std::derived_from<Event> T>
     bool removeListener(ListenerId id) {
-        if (auto listener = getListener(id); listener) { return removeListener(listener, getEventId<T>); }
+        if (auto listener = getListener(id); listener) {
+            return removeListener(listener, getEventId<T>);
+        }
         return false;
     }
     [[nodiscard]] bool hasListener(ListenerId id) const { return hasListener(id, EmptyEventId); }
diff --git a/src/ll/api/event/EventId.h b/src/ll/api/event/EventId.h
index af8ade1e32..f68e4c7290 100644
--- a/src/ll/api/event/EventId.h
+++ b/src/ll/api/event/EventId.h
@@ -20,7 +20,9 @@ class EventId {
     }
 
     [[nodiscard]] constexpr std::strong_ordering operator<=>(EventId const& other) const noexcept {
-        if (hash != other.hash) { return hash <=> other.hash; }
+        if (hash != other.hash) {
+            return hash <=> other.hash;
+        }
         return name <=> other.name;
     }
 };
diff --git a/src/ll/api/event/ListenerBase.h b/src/ll/api/event/ListenerBase.h
index 10b929f068..1713810cee 100644
--- a/src/ll/api/event/ListenerBase.h
+++ b/src/ll/api/event/ListenerBase.h
@@ -41,7 +41,9 @@ class ListenerBase {
     [[nodiscard]] constexpr bool operator!=(ListenerBase const& other) const noexcept { return id != other.id; }
 
     [[nodiscard]] constexpr std::strong_ordering operator<=>(ListenerBase const& other) const noexcept {
-        if (priority != other.priority) { return priority <=> other.priority; }
+        if (priority != other.priority) {
+            return priority <=> other.priority;
+        }
         return id <=> other.id;
     }
 
diff --git a/src/ll/api/event/filesystem/FileActionEvent.cpp b/src/ll/api/event/filesystem/FileActionEvent.cpp
index 1d3b3be6c4..63dc82b43a 100644
--- a/src/ll/api/event/filesystem/FileActionEvent.cpp
+++ b/src/ll/api/event/filesystem/FileActionEvent.cpp
@@ -48,7 +48,9 @@ class FileWatch {
     void init() {
 
         closeEvent = CreateEventW(nullptr, TRUE, FALSE, nullptr);
-        if (!closeEvent) { throw ll::error_info::getWinLastError(); }
+        if (!closeEvent) {
+            throw ll::error_info::getWinLastError();
+        }
 
 
         callbackThread = std::thread([this]() {
@@ -82,7 +84,9 @@ class FileWatch {
                 OVERLAPPED        overlapped_buffer{0};
 
                 overlapped_buffer.hEvent = CreateEventW(nullptr, TRUE, FALSE, nullptr);
-                if (!overlapped_buffer.hEvent) { std::cerr << "Error creating monitor event" << std::endl; }
+                if (!overlapped_buffer.hEvent) {
+                    std::cerr << "Error creating monitor event" << std::endl;
+                }
 
                 std::array<void*, 2> handles{overlapped_buffer.hEvent, closeEvent};
 
@@ -112,21 +116,24 @@ class FileWatch {
                         }
                         async_pending = false;
 
-                        if (bytes_returned == 0) { break; }
+                        if (bytes_returned == 0) {
+                            break;
+                        }
 
                         auto* file_information = reinterpret_cast<FILE_NOTIFY_INFORMATION*>(&buffer[0]);
                         do {
                             std::wstring changed_file{
                                 file_information->FileName,
-                                file_information->FileNameLength / sizeof(file_information->FileName[0])
-                            };
+                                file_information->FileNameLength / sizeof(file_information->FileName[0])};
                             if (passFilter(changed_file)) {
                                 parsed_information.emplace_back(
                                     Path{changed_file},
                                     (FileActionType)file_information->Action
                                 );
                             }
-                            if (file_information->NextEntryOffset == 0) { break; }
+                            if (file_information->NextEntryOffset == 0) {
+                                break;
+                            }
 
                             file_information = reinterpret_cast<FILE_NOTIFY_INFORMATION*>(
                                 reinterpret_cast<BYTE*>(file_information) + file_information->NextEntryOffset
@@ -189,7 +196,9 @@ class FileWatch {
                 return path;
             } else {
                 filename = path.filename();
-                if (!path.has_parent_path()) { return Path{u8"./"}; }
+                if (!path.has_parent_path()) {
+                    return Path{u8"./"};
+                }
                 return path.parent_path();
             }
         }();
@@ -204,7 +213,9 @@ class FileWatch {
             nullptr
         ); // file with attributes to copy
 
-        if (directory == INVALID_HANDLE_VALUE) { throw ll::error_info::getWinLastError(); }
+        if (directory == INVALID_HANDLE_VALUE) {
+            throw ll::error_info::getWinLastError();
+        }
         return directory;
     }
 
diff --git a/src/ll/api/event/filesystem/FileActionEvent.h b/src/ll/api/event/filesystem/FileActionEvent.h
index 81f6aa6ab3..33cd13034a 100644
--- a/src/ll/api/event/filesystem/FileActionEvent.h
+++ b/src/ll/api/event/filesystem/FileActionEvent.h
@@ -40,8 +40,7 @@ template <FixedString WatchedPath>
 class FileActionEvent : public DynamicFileActionEvent {
     static constexpr auto CustomIdOwn{
         FixedString<ll::reflection::type_name_v<FileActionEvent>.size()>{ll::reflection::type_name_v<FileActionEvent>}
-        + FixedString{"|"} + WatchedPath
-    };
+        + FixedString{"|"} + WatchedPath};
 
 public:
     static constexpr EventId CustomEventId{CustomIdOwn};
diff --git a/src/ll/api/form/CustomForm.cpp b/src/ll/api/form/CustomForm.cpp
index 33597220bd..a71eaca8e8 100644
--- a/src/ll/api/form/CustomForm.cpp
+++ b/src/ll/api/form/CustomForm.cpp
@@ -57,8 +57,12 @@ class Input : public CustomFormElement {
                 {"type", "input"},
                 {"text", mText  }
             };
-            if (!mPlaceholder.empty()) { input["placeholder"] = mPlaceholder; }
-            if (!mDefault.empty()) { input["default"] = mDefault; }
+            if (!mPlaceholder.empty()) {
+                input["placeholder"] = mPlaceholder;
+            }
+            if (!mDefault.empty()) {
+                input["default"] = mDefault;
+            }
             return input;
         } catch (...) {
             ll::logger.error("Failed to serialize Input");
@@ -150,8 +154,12 @@ class Slider : public CustomFormElement {
     [[nodiscard]] bool isValid() const { return mMin <= mMax && mStep > 0.0 && mDefault >= mMin && mDefault <= mMax; }
 
     void validate() {
-        if (mMin > mMax) { std::swap(mMin, mMax); }
-        if (mStep <= 0.0) { mStep = 1.0; }
+        if (mMin > mMax) {
+            std::swap(mMin, mMax);
+        }
+        if (mStep <= 0.0) {
+            mStep = 1.0;
+        }
         if (mDefault < mMin) {
             mDefault = mMin;
         } else if (mDefault > mMax) {
@@ -207,7 +215,9 @@ class StepSlider : public CustomFormElement {
     [[nodiscard]] bool isValid() const { return !mSteps.empty() && mDefault < mSteps.size(); }
 
     void validate() {
-        if (mDefault >= mSteps.size()) { mDefault = mSteps.size() - 1; }
+        if (mDefault >= mSteps.size()) {
+            mDefault = mSteps.size() - 1;
+        }
     }
 
     StepSlider(std::string name, std::string text, std::vector<std::string> steps, size_t defaultVal = 0)
@@ -311,7 +321,9 @@ class CustomForm::CustomFormImpl : public FormImpl {
         }
         uint id = handler::addFormHandler(std::make_unique<handler::CustomFormHandler>(std::move(callback), mElements));
         auto json = serialize();
-        if (json.is_null()) { return false; }
+        if (json.is_null()) {
+            return false;
+        }
         ModalFormRequestPacket(id, json.dump()).sendTo(player);
         return true;
     }
@@ -328,7 +340,9 @@ class CustomForm::CustomFormImpl : public FormImpl {
             };
             for (auto& e : mElements) {
                 nlohmann::ordered_json element = e->serialize();
-                if (!element.empty()) { form["content"].push_back(element); }
+                if (!element.empty()) {
+                    form["content"].push_back(element);
+                }
             }
             return form;
         } catch (...) {
diff --git a/src/ll/api/form/ModalForm.cpp b/src/ll/api/form/ModalForm.cpp
index 57abb6c5dd..84fb47b8b5 100644
--- a/src/ll/api/form/ModalForm.cpp
+++ b/src/ll/api/form/ModalForm.cpp
@@ -48,7 +48,9 @@ class ModalForm::ModalFormImpl : public FormImpl {
         }
         uint id   = handler::addFormHandler(std::make_unique<handler::ModalFormHandler>(std::move(callback)));
         auto json = serialize();
-        if (json.is_null()) { return false; }
+        if (json.is_null()) {
+            return false;
+        }
         ModalFormRequestPacket(id, json.dump()).sendTo(player);
         return true;
     }
diff --git a/src/ll/api/form/SimpleForm.cpp b/src/ll/api/form/SimpleForm.cpp
index 0361ba66b6..c7dd031955 100644
--- a/src/ll/api/form/SimpleForm.cpp
+++ b/src/ll/api/form/SimpleForm.cpp
@@ -22,7 +22,9 @@ class Button {
     ~Button() = default;
 
     void callback(Player& player) {
-        if (mCallback) { mCallback(player); }
+        if (mCallback) {
+            mCallback(player);
+        }
     }
 
     [[nodiscard]] nlohmann::ordered_json serialize() const {
@@ -77,11 +79,15 @@ class SimpleForm::SimpleFormImpl : public FormImpl {
         }
         std::vector<SimpleForm::ButtonCallback> buttonCallbacks;
         buttonCallbacks.reserve(mElements.size());
-        for (auto& e : mElements) { buttonCallbacks.push_back(e.mCallback); }
+        for (auto& e : mElements) {
+            buttonCallbacks.push_back(e.mCallback);
+        }
         uint id =
             handler::addFormHandler(std::make_unique<handler::SimpleFormHandler>(std::move(callback), buttonCallbacks));
         auto json = serialize();
-        if (json.is_null()) { return false; }
+        if (json.is_null()) {
+            return false;
+        }
         ModalFormRequestPacket(id, json.dump()).sendTo(player);
         return true;
     }
@@ -99,7 +105,9 @@ class SimpleForm::SimpleFormImpl : public FormImpl {
             };
             for (auto& e : mElements) {
                 nlohmann::ordered_json element = e.serialize();
-                if (!element.empty()) { form["buttons"].push_back(element); }
+                if (!element.empty()) {
+                    form["buttons"].push_back(element);
+                }
             }
             return form;
         } catch (nlohmann::ordered_json::exception const&) {
diff --git a/src/ll/api/i18n/I18nAPI.cpp b/src/ll/api/i18n/I18nAPI.cpp
index 1f7b09184a..b84d445552 100644
--- a/src/ll/api/i18n/I18nAPI.cpp
+++ b/src/ll/api/i18n/I18nAPI.cpp
@@ -19,9 +19,9 @@ const std::array<std::string, 2> GENERAL_LANGUAGES = {"en", "zh"};
 
 bool findTranslation(
     I18N::LangData const& langData,
-    std::string_view    key,
-    std::string_view    localeName,
-    std::string_view    localeType,
+    std::string_view      key,
+    std::string_view      localeName,
+    std::string_view      localeType,
     std::string&          dest
 ) {
     if (auto lang = langData.find(localeName); lang != langData.end()) { // If there is a translation for the language
@@ -33,7 +33,9 @@ bool findTranslation(
     }
     // Search for the similar language in mLangData
     for (auto& [name, translations] : langData) {
-        if (name.length() < 2) { continue; }
+        if (name.length() < 2) {
+            continue;
+        }
         if (name.substr(0, 2) == localeType) {
             if (auto it = translations.find(key); it != translations.end()) {
                 dest = it->second;
@@ -55,20 +57,28 @@ std::string I18N::get(std::string_view key, std::string localeName) {
     auto        localeType = localeName.substr(0, 2);
     std::string result;
     // Try finding the translation in loaded language data
-    if (findTranslation(mLangData, key, localeName, localeType, result)) { return result; }
+    if (findTranslation(mLangData, key, localeName, localeType, result)) {
+        return result;
+    }
     // If not found, try falling back to the default language data
     if (!mDefaultLangData.empty() && findTranslation(mDefaultLangData, key, localeName, localeType, result)) {
         return result;
     }
     // Try finding general languages
     for (auto& lang : GENERAL_LANGUAGES) {
-        if (findTranslation(mLangData, key, lang, lang, result)) { return result; }
-        if (!mDefaultLangData.empty() && findTranslation(mDefaultLangData, key, lang, lang, result)) { return result; }
+        if (findTranslation(mLangData, key, lang, lang, result)) {
+            return result;
+        }
+        if (!mDefaultLangData.empty() && findTranslation(mDefaultLangData, key, lang, lang, result)) {
+            return result;
+        }
     }
     // Use the first (dictionary order) language data
     if (!mLangData.empty()) {
         auto& lang = mLangData.begin()->second;
-        if (auto it = lang.find(key); it != lang.end()) { return it->second; }
+        if (auto it = lang.find(key); it != lang.end()) {
+            return it->second;
+        }
     }
     // Finally, still not found, return the key
     return std::string{key};
@@ -98,7 +108,9 @@ void SingleFileI18N::load(std::string const& fileName) {
     for (auto& [lang, dat] : mLangData) {
         if (mDefaultLangData.count(lang)) {
             for (auto& [k, v] : mDefaultLangData[lang]) {
-                if (!dat.count(k)) { dat[k] = v; }
+                if (!dat.count(k)) {
+                    dat[k] = v;
+                }
             }
         }
     }
@@ -141,13 +153,17 @@ I18N::SubLangData parseNestedData(nlohmann::json const& j, std::string const& pr
 void MultiFileI18N::load(std::string const& dirPath) {
     this->mDirPath = dirPath;
     if (!fs::exists(dirPath) || fs::is_empty(dirPath)) {
-        if (this->mDefaultLangData.empty()) { return; }
+        if (this->mDefaultLangData.empty()) {
+            return;
+        }
         this->mLangData = this->mDefaultLangData;
         save();
         return;
     }
     for (auto& f : fs::directory_iterator(dirPath)) {
-        if (!f.is_regular_file() || f.path().extension() != ".json") { continue; }
+        if (!f.is_regular_file() || f.path().extension() != ".json") {
+            continue;
+        }
         auto           langName = f.path().stem().string();
         std::fstream   file(f.path().wstring(), std::ios::in);
         nlohmann::json j;
diff --git a/src/ll/api/i18n/I18nAPI.h b/src/ll/api/i18n/I18nAPI.h
index 567fadd04f..6edb81aa1c 100644
--- a/src/ll/api/i18n/I18nAPI.h
+++ b/src/ll/api/i18n/I18nAPI.h
@@ -153,7 +153,9 @@ inline void load(std::string const& path) {
 template <ll::concepts::IsString S, class... Args>
 inline std::string tr(S const& formatStr, Args&&... args) {
     auto res = getInstance()->get(formatStr);
-    if constexpr (sizeof...(args) != 0) { return fmt::format(fmt::runtime(res), args...); }
+    if constexpr (sizeof...(args) != 0) {
+        return fmt::format(fmt::runtime(res), args...);
+    }
     return res;
 }
 
@@ -176,7 +178,9 @@ inline std::string tr(S const& formatStr, Args&&... args) {
 template <ll::concepts::IsString S, class... Args>
 [[nodiscard]] inline std::string trl(std::string const& localeName, S const& formatStr, Args&&... args) {
     auto res = getInstance()->get(formatStr, localeName);
-    if constexpr (sizeof...(args) != 0) { return fmt::format(fmt::runtime(res), args...); }
+    if constexpr (sizeof...(args) != 0) {
+        return fmt::format(fmt::runtime(res), args...);
+    }
     return res;
 }
 
diff --git a/src/ll/api/io/FileUtils.cpp b/src/ll/api/io/FileUtils.cpp
index a89be70251..03fbf3dc0f 100644
--- a/src/ll/api/io/FileUtils.cpp
+++ b/src/ll/api/io/FileUtils.cpp
@@ -22,7 +22,9 @@ std::optional<std::string> readFile(const fs::path& filePath, bool isBinary) {
     std::ios_base::openmode mode = std::ios_base::in;
     if (isBinary) mode |= std::ios_base::binary;
     fRead.open(filePath, mode);
-    if (!fRead.is_open()) { return std::nullopt; }
+    if (!fRead.is_open()) {
+        return std::nullopt;
+    }
     std::string data((std::istreambuf_iterator<char>(fRead)), {});
     fRead.close();
     return data;
@@ -33,7 +35,9 @@ bool writeFile(const fs::path& filePath, std::string_view content, bool isBinary
     std::ios_base::openmode mode = std::ios_base::out;
     if (isBinary) mode |= std::ios_base::binary;
     fWrite.open(filePath, mode);
-    if (!fWrite.is_open()) { return false; }
+    if (!fWrite.is_open()) {
+        return false;
+    }
     fWrite << content;
     fWrite.close();
     return true;
@@ -50,9 +54,13 @@ static bool getFileVersion(
 
     DWORD dwHandle = 0;
     DWORD dwLen    = GetFileVersionInfoSizeW(filePath, &dwHandle);
-    if (0 >= dwLen) { return false; }
+    if (0 >= dwLen) {
+        return false;
+    }
     auto* pBlock = new (std::nothrow) wchar_t[dwLen];
-    if (nullptr == pBlock) { return false; }
+    if (nullptr == pBlock) {
+        return false;
+    }
     if (!GetFileVersionInfoW(filePath, dwHandle, dwLen, pBlock)) {
         delete[] pBlock;
         return false;
diff --git a/src/ll/api/memory/Closure.cpp b/src/ll/api/memory/Closure.cpp
index f7cd373d31..7916db0767 100644
--- a/src/ll/api/memory/Closure.cpp
+++ b/src/ll/api/memory/Closure.cpp
@@ -7,7 +7,9 @@
 namespace ll::memory::detail {
 size_t getVolatileOffset(void* fn) {
     for (size_t offset = 0; offset < 4096; offset++) {
-        if (*(uintptr_t*)((uintptr_t)fn + offset) == (uintptr_t)closureMagicNumber) { return offset; }
+        if (*(uintptr_t*)((uintptr_t)fn + offset) == (uintptr_t)closureMagicNumber) {
+            return offset;
+        }
     }
     throw std::runtime_error("can't parse closure asm offset");
 };
diff --git a/src/ll/api/memory/Hook.h b/src/ll/api/memory/Hook.h
index 33ff10c840..c3b8623da9 100644
--- a/src/ll/api/memory/Hook.h
+++ b/src/ll/api/memory/Hook.h
@@ -25,9 +25,13 @@
                     );                                                                                                 \
                 }                                                                                                      \
                 fmt::print("\x1b[96m v resolve [" #IDENTIFIER "] to:\x1b[0m\r\n");                                     \
-                for (auto& str : symbols) { fmt::print(" {} {}\r\n", (&str == &symbols.back()) ? '-' : '|', str); }    \
+                for (auto& str : symbols) {                                                                            \
+                    fmt::print(" {} {}\r\n", (&str == &symbols.back()) ? '-' : '|', str);                              \
+                }                                                                                                      \
             }                                                                                                          \
-        } catch (...) { fmt::print("\x1b[91m!!! Exception in resolve: [" #IDENTIFIER "]\x1b[0m\r\n"); }                  \
+        } catch (...) {                                                                                                \
+            fmt::print("\x1b[91m!!! Exception in resolve: [" #IDENTIFIER "]\x1b[0m\r\n");                              \
+        }                                                                                                              \
         return 0;                                                                                                      \
     };                                                                                                                 \
     static inline int debugging = debugger()
@@ -138,7 +142,9 @@ struct HookAutoRegister {
                                                                                                                        \
         static int hook() {                                                                                            \
             target = ll::memory::resolveIdentifier<OriginFuncType>(IDENTIFIER);                                        \
-            if (target == nullptr) { return -1; }                                                                      \
+            if (target == nullptr) {                                                                                   \
+                return -1;                                                                                             \
+            }                                                                                                          \
             return ll::memory::hook(                                                                                   \
                 target,                                                                                                \
                 ll::memory::toFuncPtr(&DEF_TYPE::detour),                                                              \
diff --git a/src/ll/api/memory/Memory.cpp b/src/ll/api/memory/Memory.cpp
index 70cbe2ad5a..3c85363718 100644
--- a/src/ll/api/memory/Memory.cpp
+++ b/src/ll/api/memory/Memory.cpp
@@ -64,9 +64,11 @@ FuncPtr resolveSignature(char const* signature) {
 
 std::vector<std::string> lookupSymbol(FuncPtr func) {
     std::vector<std::string> symbols;
-    size_t length;
-    auto   result = pl::symbol_provider::pl_lookup_symbol(func, &length);
-    for (size_t i = 0; i < length; i++) { symbols.emplace_back(result[i]); }
+    size_t                   length;
+    auto                     result = pl::symbol_provider::pl_lookup_symbol(func, &length);
+    for (size_t i = 0; i < length; i++) {
+        symbols.emplace_back(result[i]);
+    }
     if (result) pl::symbol_provider::pl_free_lookup_result(result);
     return symbols;
 }
diff --git a/src/ll/api/memory/Memory.h b/src/ll/api/memory/Memory.h
index ce33f50a97..5190777243 100644
--- a/src/ll/api/memory/Memory.h
+++ b/src/ll/api/memory/Memory.h
@@ -119,13 +119,17 @@ constexpr auto construct(void* ptr, ptrdiff_t off, Types&&... args) {
 }
 
 [[nodiscard]] inline size_t getMemSizeFromPtr(void* ptr) {
-    if (!ptr) { return 0; }
+    if (!ptr) {
+        return 0;
+    }
     return _msize(ptr);
 }
 
 template <class T, class D>
 [[nodiscard]] inline size_t getMemSizeFromPtr(std::unique_ptr<T, D>& ptr) {
-    if (!ptr) { return 0; }
+    if (!ptr) {
+        return 0;
+    }
     return _msize(ptr.get());
 }
 
@@ -134,11 +138,17 @@ template <template <class> class P, class T>
     requires(std::derived_from<P<T>, std::_Ptr_base<T>>)
 {
     auto& refc = dAccess<std::_Ref_count_base*>(std::addressof(ptr), 8);
-    if (!refc) { return 0; }
+    if (!refc) {
+        return 0;
+    }
     auto& rawptr = dAccess<T*>(std::addressof(ptr), 0);
-    if (!rawptr) { return 0; }
+    if (!rawptr) {
+        return 0;
+    }
     if constexpr (!std::is_array_v<T>) {
-        if (rawptr == dAccess<T*>(refc, 8 + 4 * 2)) { return getMemSizeFromPtr(rawptr); }
+        if (rawptr == dAccess<T*>(refc, 8 + 4 * 2)) {
+            return getMemSizeFromPtr(rawptr);
+        }
     }
     // clang-format off
     return _msize(refc // ptr* 8, rep* 8
diff --git a/src/ll/api/memory/PatchHelper.h b/src/ll/api/memory/PatchHelper.h
index 1c61d57b8c..5cfae1a882 100644
--- a/src/ll/api/memory/PatchHelper.h
+++ b/src/ll/api/memory/PatchHelper.h
@@ -55,9 +55,13 @@ struct PatchHelper {
     using ref_t = uchar (&)[len];
     constexpr bool operator==(ref_t ref) const noexcept { return memcmp(data, ref, sizeof data) == 0; }
     constexpr bool operator!=(ref_t ref) const noexcept { return memcmp(data, ref, sizeof data) != 0; }
-    constexpr bool operator==(PatchHelper const& ref) const noexcept { return memcmp(data, ref.data, sizeof data) == 0; }
-    constexpr bool operator!=(PatchHelper const& ref) const noexcept { return memcmp(data, ref.data, sizeof data) != 0; }
-    PatchHelper&   operator=(ref_t ref) { memcpy(data, ref, sizeof data); }
+    constexpr bool operator==(PatchHelper const& ref) const noexcept {
+        return memcmp(data, ref.data, sizeof data) == 0;
+    }
+    constexpr bool operator!=(PatchHelper const& ref) const noexcept {
+        return memcmp(data, ref.data, sizeof data) != 0;
+    }
+    PatchHelper& operator=(ref_t ref) { memcpy(data, ref, sizeof data); }
 
     bool doPatch(PatchHelper expected, PatchHelper patched) {
         if (*this == expected) {
diff --git a/src/ll/api/plugin/Plugin.h b/src/ll/api/plugin/Plugin.h
index 6079156a38..1ece42c18b 100644
--- a/src/ll/api/plugin/Plugin.h
+++ b/src/ll/api/plugin/Plugin.h
@@ -81,13 +81,17 @@ class Plugin : public std::enable_shared_from_this<Plugin> {
 
     template <class T>
     optional_ref<std::add_const_t<T>> getSharedData(std::string_view key) const {
-        if (getSharedData().contains(key)) { return std::any_cast<T>(&getSharedData().find(key)->second); }
+        if (getSharedData().contains(key)) {
+            return std::any_cast<T>(&getSharedData().find(key)->second);
+        }
         return std::nullopt;
     }
 
     template <class T>
     optional_ref<T> getSharedData(std::string_view key) {
-        if (getSharedData().contains(key)) { return std::any_cast<T>(&getSharedData().find(key)->second); }
+        if (getSharedData().contains(key)) {
+            return std::any_cast<T>(&getSharedData().find(key)->second);
+        }
         return std::nullopt;
     }
 
@@ -99,7 +103,9 @@ class Plugin : public std::enable_shared_from_this<Plugin> {
 
     [[maybe_unused]] void removeSharedData(std::string_view key) {
         auto it = getSharedData().find(key);
-        if (it != getSharedData().end()) { getSharedData().erase(it); }
+        if (it != getSharedData().end()) {
+            getSharedData().erase(it);
+        }
     }
 
     // throw exception if not found
diff --git a/src/ll/api/plugin/PluginManager.cpp b/src/ll/api/plugin/PluginManager.cpp
index 12c27ffa91..2fca8e3a9f 100644
--- a/src/ll/api/plugin/PluginManager.cpp
+++ b/src/ll/api/plugin/PluginManager.cpp
@@ -37,7 +37,9 @@ auto PluginManager::getInstance() -> PluginManager& {
 
 auto PluginManager::registerPlugin(std::shared_ptr<Plugin> const& plugin) -> bool {
     std::lock_guard<std::recursive_mutex> lock(mImpl->mutex);
-    if (mImpl->nameMap.contains(plugin->getManifest().name)) { return false; }
+    if (mImpl->nameMap.contains(plugin->getManifest().name)) {
+        return false;
+    }
     mImpl->plugins.push_back(plugin);
     mImpl->handleMap.insert_or_assign(plugin->getHandle(), plugin);
     mImpl->nameMap.insert_or_assign(plugin->getManifest().name, plugin);
@@ -69,7 +71,9 @@ auto PluginManager::findPlugin(Handle handle) -> std::weak_ptr<const Plugin> {
 auto PluginManager::getAllPlugins() -> std::vector<std::weak_ptr<const Plugin>> {
     std::lock_guard<std::recursive_mutex>    lock(mImpl->mutex);
     std::vector<std::weak_ptr<const Plugin>> plugins;
-    for (auto& plugin : mImpl->plugins) { plugins.push_back(plugin); }
+    for (auto& plugin : mImpl->plugins) {
+        plugins.push_back(plugin);
+    }
     return plugins;
 }
 
@@ -82,8 +86,12 @@ auto PluginManager::loadAllPlugins() -> void {
     fs::directory_iterator ent(pluginDir);
 
     for (auto& file : ent) {
-        if (!file.is_directory()) { continue; }
-        if (loadPlugin(u8sv2sv(file.path().filename().u8string()))) { pluginCount++; }
+        if (!file.is_directory()) {
+            continue;
+        }
+        if (loadPlugin(u8sv2sv(file.path().filename().u8string()))) {
+            pluginCount++;
+        }
     }
 
     ll::logger.info("ll.loader.loadMain.done"_tr, pluginCount);
@@ -91,27 +99,39 @@ auto PluginManager::loadAllPlugins() -> void {
 
 auto PluginManager::unloadAllPlugins() -> void {
     std::lock_guard<std::recursive_mutex> lock(mImpl->mutex);
-    for (auto& plugin : mImpl->plugins) { unloadPlugin(plugin); }
+    for (auto& plugin : mImpl->plugins) {
+        unloadPlugin(plugin);
+    }
 }
 
 auto PluginManager::enableAllPlugins() -> void {
     std::lock_guard<std::recursive_mutex> lock(mImpl->mutex);
-    for (auto& plugin : mImpl->plugins) { enablePlugin(plugin); }
+    for (auto& plugin : mImpl->plugins) {
+        enablePlugin(plugin);
+    }
 }
 
 auto PluginManager::disableAllPlugins() -> void {
     std::lock_guard<std::recursive_mutex> lock(mImpl->mutex);
-    for (auto& plugin : mImpl->plugins) { disablePlugin(plugin); }
+    for (auto& plugin : mImpl->plugins) {
+        disablePlugin(plugin);
+    }
 }
 
 auto PluginManager::loadPlugin(std::string_view pluginName) -> std::shared_ptr<Plugin> {
     std::lock_guard<std::recursive_mutex> lock(mImpl->mutex);
     auto                                  manifestPath = pluginDir / sv2u8sv(pluginName) / "manifest.json";
-    if (!fs::exists(manifestPath)) { return {}; }
+    if (!fs::exists(manifestPath)) {
+        return {};
+    }
     auto content = file_utils::readFile(manifestPath);
-    if (!content) { return {}; }
+    if (!content) {
+        return {};
+    }
     auto json = nlohmann::json::parse(content.value(), nullptr, false, true);
-    if (json.is_discarded()) { return {}; }
+    if (json.is_discarded()) {
+        return {};
+    }
 
     Manifest manifest;
     try {
@@ -157,7 +177,9 @@ auto PluginManager::loadPlugin(std::string_view pluginName) -> std::shared_ptr<P
 auto PluginManager::unloadPlugin(const std::weak_ptr<const Plugin>& plugin) -> bool {
     std::lock_guard<std::recursive_mutex> lock(mImpl->mutex);
     if (auto ptr = plugin.lock()) {
-        if (ptr->getState() != PluginState::Disabled) { disablePlugin(plugin); }
+        if (ptr->getState() != PluginState::Disabled) {
+            disablePlugin(plugin);
+        }
         if (!ptr->onUnload()) {
             ll::logger.error("Fail to unload plugin <{}>!", ptr->getManifest().name);
             return false;
@@ -178,7 +200,9 @@ auto PluginManager::unloadPlugin(const std::weak_ptr<const Plugin>& plugin) -> b
 auto PluginManager::enablePlugin(const std::weak_ptr<const Plugin>& plugin) -> bool {
     std::lock_guard<std::recursive_mutex> lock(mImpl->mutex);
     if (auto ptr = plugin.lock()) {
-        if (ptr->getState() == PluginState::Enabled) { return true; }
+        if (ptr->getState() == PluginState::Enabled) {
+            return true;
+        }
         if (!ptr->onEnable()) {
             ll::logger.error("Fail to enable plugin <{}>!", ptr->getManifest().name);
             return false;
@@ -192,7 +216,9 @@ auto PluginManager::enablePlugin(const std::weak_ptr<const Plugin>& plugin) -> b
 auto PluginManager::disablePlugin(const std::weak_ptr<const Plugin>& plugin) -> bool {
     std::lock_guard<std::recursive_mutex> lock(mImpl->mutex);
     if (auto ptr = plugin.lock()) {
-        if (ptr->getState() == PluginState::Disabled) { return true; }
+        if (ptr->getState() == PluginState::Disabled) {
+            return true;
+        }
         if (!ptr->onDisable()) {
             ll::logger.error("Fail to disable plugin <{}>!", ptr->getManifest().name);
             return false;
diff --git a/src/ll/api/reflection/Reflection.h b/src/ll/api/reflection/Reflection.h
index a9137665e1..4cced88c6c 100644
--- a/src/ll/api/reflection/Reflection.h
+++ b/src/ll/api/reflection/Reflection.h
@@ -65,22 +65,34 @@ consteval std::string_view typeRawName() noexcept {
 }
 
 constexpr std::string_view removeTypePrefix(std::string_view s) noexcept {
-    if (s.starts_with("enum ")) { s.remove_prefix(sizeof("enum ") - 1); }
-    if (s.starts_with("class ")) { s.remove_prefix(sizeof("class ") - 1); }
-    if (s.starts_with("union ")) { s.remove_prefix(sizeof("union ") - 1); }
-    if (s.starts_with("struct ")) { s.remove_prefix(sizeof("struct ") - 1); }
+    if (s.starts_with("enum ")) {
+        s.remove_prefix(sizeof("enum ") - 1);
+    }
+    if (s.starts_with("class ")) {
+        s.remove_prefix(sizeof("class ") - 1);
+    }
+    if (s.starts_with("union ")) {
+        s.remove_prefix(sizeof("union ") - 1);
+    }
+    if (s.starts_with("struct ")) {
+        s.remove_prefix(sizeof("struct ") - 1);
+    }
     return s;
 }
 
 constexpr std::string_view removeTypeSuffix(std::string_view s) noexcept {
     auto k = s.find('<');
-    if (k != std::string_view::npos) { return s.substr(0, k); }
+    if (k != std::string_view::npos) {
+        return s.substr(0, k);
+    }
     return s;
 }
 
 constexpr std::string_view removeTypeNamespace(std::string_view s) noexcept {
     auto k = s.rfind("::", s.find('<'));
-    if (k != std::string_view::npos) { return s.substr(k + 2); }
+    if (k != std::string_view::npos) {
+        return s.substr(k + 2);
+    }
     return s;
 }
 
diff --git a/src/ll/api/reflection/Serialization.h b/src/ll/api/reflection/Serialization.h
index 60c001aab0..d62df57fab 100644
--- a/src/ll/api/reflection/Serialization.h
+++ b/src/ll/api/reflection/Serialization.h
@@ -2,25 +2,56 @@
 
 #include "ll/api/reflection/Reflection.h"
 
+#include "fmt/format.h"
+
 namespace ll::reflection {
 
-class SerializationError : public std::runtime_error {
+class SerializationError : public std::exception {
+    std::string           mField;
+    std::string           mMsg;
+    std::exception const* mErr{};
+
 public:
-    explicit SerializationError(std::string const& msg) : std::runtime_error(msg) {}
+    SerializationError(std::string_view field, std::exception const& err) : mField(field), mErr(&err) {
+        mMsg = fmt::format("Serialization error in field '{}': {}", field, err.what());
+    }
+
+    SerializationError(std::string_view field, SerializationError const& other) {
+        mField = fmt::format("{}.{}", field, other.mField);
+        mErr   = other.mErr;
+        mMsg   = fmt::format(
+            "Serialization error in field '{}': {}",
+            mField,
+            other.mErr ? other.mErr->what() : "Unknown error"
+        );
+    }
+
+    explicit SerializationError(std::string_view field) : mField(field) {
+        mMsg = fmt::format("Serialization error in field '{}'", field);
+    }
+
+    [[nodiscard]] char const* what() const noexcept override { return mMsg.c_str(); }
+
+    [[nodiscard]] std::string_view field() const noexcept { return mField; };
+
+    [[nodiscard]] std::exception const* error() const noexcept { return mErr; };
 };
 
 template <class J, Reflectable T>
 inline J serialize(T const&)
     requires(!std::convertible_to<T, J>);
+
 template <class J, Reflectable T, class F>
 inline J serialize(T const&, F&&)
     requires(!std::convertible_to<T, J>);
+
 template <class J, Reflectable T>
 inline void deserialize(T&, J const&);
 
 template <class J, class T>
 inline J serialize(T const&)
     requires(std::is_enum_v<T>);
+
 template <class J, class T>
 inline void deserialize(T&, J const&)
     requires(std::is_enum_v<T>);
@@ -28,6 +59,7 @@ inline void deserialize(T&, J const&)
 template <class J, std::convertible_to<J> T>
 inline J serialize(T const&)
     requires(!std::is_enum_v<T>);
+
 template <class J, class T>
 inline void deserialize(T&, J const&)
     requires(
@@ -38,6 +70,7 @@ inline void deserialize(T&, J const&)
 template <class J, ll::concepts::Associative T>
 inline J serialize(T const&)
     requires(std::is_convertible_v<typename T::key_type, std::string_view> && !std::convertible_to<T, J>);
+
 template <class J, ll::concepts::Associative T>
 inline void deserialize(T&, J const&)
     requires(std::is_convertible_v<typename T::key_type, std::string_view>);
@@ -51,12 +84,14 @@ inline void deserialize(T&, J const&);
 template <class J, ll::concepts::ArrayLike T>
 inline J serialize(T const&)
     requires(!std::convertible_to<T, J>);
+
 template <class J, ll::concepts::ArrayLike T>
 inline void deserialize(T&, J const&)
     requires(!std::is_convertible_v<T, std::string_view>);
 
 template <class J, ll::concepts::IsOptional T>
 inline J serialize(T const&);
+
 template <class J, ll::concepts::IsOptional T>
 inline void deserialize(T&, J const&);
 
@@ -72,8 +107,12 @@ inline J serialize(T const& obj)
             try {
                 auto j = serialize<J>(member);
                 if (!j.is_null()) res[std::string{name}] = j;
+            } catch (SerializationError const& e) {
+                throw SerializationError{name, e};
+            } catch (std::exception const& e) {
+                throw SerializationError{name, e};
             } catch (...) {
-                std::throw_with_nested(SerializationError("error in serialize field: " + std::string{name}));
+                throw SerializationError{name};
             }
         } else {
             static_assert(ll::concepts::always_false<MemberType>, "this type can't serialize");
@@ -81,6 +120,7 @@ inline J serialize(T const& obj)
     });
     return res;
 }
+
 template <class J, Reflectable T>
 inline void deserialize(T& obj, J const& j) {
     forEachMember(obj, [&](std::string_view name, auto& member) {
@@ -90,13 +130,19 @@ inline void deserialize(T& obj, J const& j) {
             if constexpr (requires(MemberType& o, J const& s) { deserialize<J>(o, s); }) {
                 try {
                     deserialize<J>(member, j[sname]);
-                } catch (...) { std::throw_with_nested(SerializationError("error in deserialize field: " + sname)); }
+                } catch (SerializationError const& e) {
+                    throw SerializationError{sname, e};
+                } catch (std::exception const& e) {
+                    throw SerializationError{sname, e};
+                } catch (...) {
+                    throw SerializationError{sname};
+                }
             } else {
                 static_assert(ll::concepts::always_false<MemberType>, "this type can't deserialize");
             }
         } else {
             if constexpr (!ll::concepts::IsOptional<MemberType>) {
-                throw SerializationError("missing deserialization mandatory field: " + sname);
+                throw std::runtime_error("missing required field when deserializing");
             } else {
                 member = std::nullopt;
             }
@@ -110,6 +156,7 @@ inline J serialize(T const& e)
 {
     return magic_enum::enum_name(e);
 }
+
 template <class J, class T>
 inline void deserialize(T& e, J const& j)
     requires(std::is_enum_v<T>)
@@ -128,6 +175,7 @@ inline J serialize(T const& obj)
 {
     return obj;
 }
+
 template <class J, class T>
 inline void deserialize(T& obj, J const& j) // TODO: improve this
     requires(
@@ -136,9 +184,9 @@ inline void deserialize(T& obj, J const& j) // TODO: improve this
     )
 {
     if constexpr (std::is_convertible_v<T, std::string_view>) {
-        if (!j.is_string()) throw SerializationError("field must be a string");
+        if (!j.is_string()) throw std::runtime_error("field must be a string");
     } else {
-        if (!j.is_number() && !j.is_boolean()) throw SerializationError("field must be a number");
+        if (!j.is_number() && !j.is_boolean()) throw std::runtime_error("field must be a number");
     }
     obj = j;
 }
@@ -148,16 +196,21 @@ inline J serialize(T const& map)
     requires(std::is_convertible_v<typename T::key_type, std::string_view> && !std::convertible_to<T, J>)
 {
     J res;
-    for (auto& [k, v] : map) { res[std::string{k}] = serialize<J>(v); }
+    for (auto& [k, v] : map) {
+        res[std::string{k}] = serialize<J>(v);
+    }
     return res;
 }
+
 template <class J, ll::concepts::Associative T>
 inline void deserialize(T& map, J const& j)
     requires(std::is_convertible_v<typename T::key_type, std::string_view>)
 {
-    if (!j.is_object()) throw SerializationError("field must be an object");
+    if (!j.is_object()) throw std::runtime_error("field must be an object");
     map.clear();
-    for (auto& [k, v] : j.items()) { deserialize<J>(map[k], v); }
+    for (auto& [k, v] : j.items()) {
+        deserialize<J>(map[k], v);
+    }
 }
 
 template <class J, ll::concepts::TupleLike T>
@@ -168,9 +221,10 @@ inline J serialize(T const& tuple)
     std::apply([&](auto&&... args) { ((res.push_back(serialize<J>(args))), ...); }, tuple);
     return res;
 }
+
 template <class J, ll::concepts::TupleLike T>
 inline void deserialize(T& tuple, J const& j) {
-    if (!j.is_array()) throw SerializationError("field must be an array");
+    if (!j.is_array()) throw std::runtime_error("field must be an array");
     size_t i = 0;
     std::apply([&](auto&... args) { (((i < j.size()) ? deserialize<J>(args, j[i++]) : void()), ...); }, tuple);
 }
@@ -180,23 +234,30 @@ inline J serialize(T const& arr)
     requires(!std::convertible_to<T, J>)
 {
     J res;
-    for (auto& val : arr) { res.push_back(serialize<J>(val)); }
+    for (auto& val : arr) {
+        res.push_back(serialize<J>(val));
+    }
     return res;
 }
+
 template <class J, ll::concepts::ArrayLike T>
 inline void deserialize(T& arr, J const& j)
     requires(!std::is_convertible_v<T, std::string_view>)
 {
-    if (!j.is_array()) throw SerializationError("field must be an array");
+    if (!j.is_array()) throw std::runtime_error("field must be an array");
 
     using ValueType = typename T::value_type;
 
-    if constexpr (requires(T a) { a.clear(); }) { arr.clear(); }
+    if constexpr (requires(T a) { a.clear(); }) {
+        arr.clear();
+    }
 
     if constexpr (requires(T a, ValueType v) { a.push_back(v); }) {
 
         arr.resize(j.size());
-        for (size_t i = 0; i < j.size(); i++) { deserialize<J>(arr[i], j[i]); }
+        for (size_t i = 0; i < j.size(); i++) {
+            deserialize<J>(arr[i], j[i]);
+        }
 
     } else if constexpr (requires(T a, ValueType v) { a.insert(ValueType{}); }) {
 
@@ -207,15 +268,20 @@ inline void deserialize(T& arr, J const& j)
         }
 
     } else if constexpr (requires(T a, size_t v) { a.at(v); }) {
-        for (size_t i = 0; i < arr.size(); i++) { deserialize<J>(arr.at(i), j[i]); }
+        for (size_t i = 0; i < arr.size(); i++) {
+            deserialize<J>(arr.at(i), j[i]);
+        }
     }
 }
 
 template <class J, ll::concepts::IsOptional T>
 inline J serialize(T const& opt) {
-    if (!opt) { return nullptr; }
+    if (!opt) {
+        return nullptr;
+    }
     return serialize<J>(*opt);
 }
+
 template <class J, ll::concepts::IsOptional T>
 inline void deserialize(T& opt, J const& j) {
     if (j.is_null()) {
@@ -224,4 +290,5 @@ inline void deserialize(T& opt, J const& j) {
         deserialize<J>(*opt, j);
     }
 }
-} // namespace ll::reflection
\ No newline at end of file
+
+} // namespace ll::reflection
diff --git a/src/ll/api/schedule/Scheduler.h b/src/ll/api/schedule/Scheduler.h
index 0229e298e0..1191589db3 100644
--- a/src/ll/api/schedule/Scheduler.h
+++ b/src/ll/api/schedule/Scheduler.h
@@ -50,10 +50,14 @@ class Scheduler {
 
     std::weak_ptr<Task<Clock>> addTask(TaskPtr t) {
         std::weak_ptr<Task<Clock>> res = t;
-        if (t->cancelled) { return res; }
+        if (t->cancelled) {
+            return res;
+        }
 
         auto time = t->getNextTime();
-        if (time >= TimePoint::max()) { return res; }
+        if (time >= TimePoint::max()) {
+            return res;
+        }
 
         std::lock_guard l{mutex};
 
@@ -65,28 +69,40 @@ class Scheduler {
     void manageTasks() {
         std::lock_guard l{mutex};
         auto            end = tasks.upper_bound(Clock::now());
-        if (end == tasks.begin()) { return; }
+        if (end == tasks.begin()) {
+            return;
+        }
         TaskType temp;
 
         for (auto i = tasks.begin(); i != end; ++i) {
             auto& task = i->second;
-            if (task->cancelled) { continue; }
+            if (task->cancelled) {
+                continue;
+            }
             if (task->interval) {
                 threads.addTask([this, task] {
                     try {
                         task->f();
-                    } catch (...) { detail::printScheduleError(); }
+                    } catch (...) {
+                        detail::printScheduleError();
+                    }
                     addTask(task);
                 });
             } else {
                 threads.addTask([task] {
                     try {
                         task->f();
-                    } catch (...) { detail::printScheduleError(); }
+                    } catch (...) {
+                        detail::printScheduleError();
+                    }
                 });
-                if (task->cancelled) { continue; }
+                if (task->cancelled) {
+                    continue;
+                }
                 auto time = task->getNextTime();
-                if (time < TimePoint::max()) { temp.emplace(time, std::move(task)); }
+                if (time < TimePoint::max()) {
+                    temp.emplace(time, std::move(task));
+                }
             }
         }
         tasks.erase(tasks.begin(), end);
diff --git a/src/ll/api/schedule/Task.cpp b/src/ll/api/schedule/Task.cpp
index 6fd02d59d6..011e50db54 100644
--- a/src/ll/api/schedule/Task.cpp
+++ b/src/ll/api/schedule/Task.cpp
@@ -10,7 +10,9 @@ std::optional<time_t> tryParseTime(std::string const& expression, std::string_vi
     auto              time_now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
     std::tm           tm{};
     localtime_s(&tm, &time_now);
-    if ((ss >> std::get_time(&tm, format.data())).fail()) { return std::nullopt; }
+    if ((ss >> std::get_time(&tm, format.data())).fail()) {
+        return std::nullopt;
+    }
     return std::mktime(&tm);
 }
 
@@ -18,7 +20,9 @@ std::chrono::system_clock::time_point parseTime(std::string const& expression) {
 
     if (auto res = tryParseTime(expression, "%H:%M:%S"); res) {
         auto time = std::chrono::system_clock::from_time_t(res.value());
-        if (std::chrono::system_clock::now() > time) { time += std::chrono::hours(24); }
+        if (std::chrono::system_clock::now() > time) {
+            time += std::chrono::hours(24);
+        }
         return time;
     }
     return std::chrono::system_clock::from_time_t(
diff --git a/src/ll/api/schedule/Task.h b/src/ll/api/schedule/Task.h
index 71dba83b83..91ed7b862a 100644
--- a/src/ll/api/schedule/Task.h
+++ b/src/ll/api/schedule/Task.h
@@ -106,10 +106,7 @@ class DelayTask : public Task<Clock> {
     bool            finished;
 
 public:
-    DelayTask(TimePoint time, std::function<void()> const& f)
-    : Task<Clock>(f, false),
-      time(time),
-      finished(false) {}
+    DelayTask(TimePoint time, std::function<void()> const& f) : Task<Clock>(f, false), time(time), finished(false) {}
 
     template <class R, class P>
     DelayTask(std::chrono::duration<R, P> duration, std::function<void()> const& f)
@@ -120,7 +117,9 @@ class DelayTask : public Task<Clock> {
     : DelayTask<Clock>(parseTime(timestr), f) {}
 
     TimePoint getNextTime() override {
-        if (finished) { return TimePoint::max(); }
+        if (finished) {
+            return TimePoint::max();
+        }
         finished = true;
         return time;
     }
diff --git a/src/ll/api/service/GlobalService.cpp b/src/ll/api/service/GlobalService.cpp
index 71dd315370..c7e6495800 100644
--- a/src/ll/api/service/GlobalService.cpp
+++ b/src/ll/api/service/GlobalService.cpp
@@ -186,7 +186,12 @@ LL_AUTO_TYPED_INSTANCE_HOOK(
     ll::Global<ResourcePackRepository>.init(this);
     origin();
 }
-LL_AUTO_INSTANCE_HOOK(ResourcePackRepositoryDestructor, HookPriority::High, "??1ResourcePackRepository@@QEAA@XZ", void) {
+LL_AUTO_INSTANCE_HOOK(
+    ResourcePackRepositoryDestructor,
+    HookPriority::High,
+    "??1ResourcePackRepository@@QEAA@XZ",
+    void
+) {
     ll::Global<ResourcePackRepository>.init(nullptr);
     origin();
 }
diff --git a/src/ll/api/utils/StacktraceUtils.cpp b/src/ll/api/utils/StacktraceUtils.cpp
index d155558749..e75cdf2f50 100644
--- a/src/ll/api/utils/StacktraceUtils.cpp
+++ b/src/ll/api/utils/StacktraceUtils.cpp
@@ -15,13 +15,17 @@
 namespace ll::utils::stacktrace_utils {
 
 SymbolLoader::SymbolLoader() : handle(GetCurrentProcess()) {
-    if (!SymInitializeW(handle, nullptr, true)) { throw error_info::getWinLastError(); }
+    if (!SymInitializeW(handle, nullptr, true)) {
+        throw error_info::getWinLastError();
+    }
     DWORD options  = SymGetOptions();
     options       |= SYMOPT_LOAD_LINES | SYMOPT_EXACT_SYMBOLS;
     SymSetOptions(options);
 }
 SymbolLoader::SymbolLoader(std::string const& path) : handle(GetCurrentProcess()) {
-    if (!SymInitializeW(handle, string_utils::str2wstr(path).c_str(), true)) { throw error_info::getWinLastError(); }
+    if (!SymInitializeW(handle, string_utils::str2wstr(path).c_str(), true)) {
+        throw error_info::getWinLastError();
+    }
     DWORD options  = SymGetOptions();
     options       |= SYMOPT_LOAD_LINES | SYMOPT_EXACT_SYMBOLS;
     SymSetOptions(options);
@@ -74,8 +78,12 @@ std::string toString(std::stacktrace_entry const& entry) {
 std::string toString(std::stacktrace const& t) {
     std::string res;
     auto        maxsize = std::to_string(t.size() - 1).size();
-    for (size_t i = 0; i < t.size(); i++) { res += fmt::format("{1:>{0}}> {2}\n", maxsize, i, toString(t[i])); }
-    if (res.ends_with('\n')) { res.pop_back(); }
+    for (size_t i = 0; i < t.size(); i++) {
+        res += fmt::format("{1:>{0}}> {2}\n", maxsize, i, toString(t[i]));
+    }
+    if (res.ends_with('\n')) {
+        res.pop_back();
+    }
     return res;
 }
 std::string toString(_CONTEXT const& c) {
diff --git a/src/ll/api/utils/StringUtils.cpp b/src/ll/api/utils/StringUtils.cpp
index 58bd911933..85931d7a42 100644
--- a/src/ll/api/utils/StringUtils.cpp
+++ b/src/ll/api/utils/StringUtils.cpp
@@ -53,10 +53,14 @@ fmt::text_style getTextStyleFromCode(std::string_view code) {
         if (code.find(';') != std::string_view::npos) {
             bool background = code.starts_with('4');
             code.remove_prefix(1);
-            if (!code.starts_with("8;2;")) { return {}; }
+            if (!code.starts_with("8;2;")) {
+                return {};
+            }
             code.remove_prefix(4);
             auto svec = splitByPattern(code, ";");
-            if (svec.size() != 3) { return {}; }
+            if (svec.size() != 3) {
+                return {};
+            }
             auto colorFromCode = fmt::rgb(svtouc(svec[0]), svtouc(svec[1]), svtouc(svec[2]));
             if (background) {
                 return fmt::bg(colorFromCode);
@@ -95,9 +99,15 @@ std::string getMcCodeFromTextStyle(fmt::text_style style) {
     bool        hasMcStyle = false;
     if (style.has_emphasis()) {
         hasMcStyle = true;
-        if ((uchar)(fmt::emphasis::blink) & (uchar)(style.get_emphasis())) { res += "§k"; }
-        if ((uchar)(fmt::emphasis::bold) & (uchar)(style.get_emphasis())) { res += "§l"; }
-        if ((uchar)(fmt::emphasis::italic) & (uchar)(style.get_emphasis())) { res += "§o"; }
+        if ((uchar)(fmt::emphasis::blink) & (uchar)(style.get_emphasis())) {
+            res += "§k";
+        }
+        if ((uchar)(fmt::emphasis::bold) & (uchar)(style.get_emphasis())) {
+            res += "§l";
+        }
+        if ((uchar)(fmt::emphasis::italic) & (uchar)(style.get_emphasis())) {
+            res += "§o";
+        }
     }
     if (style.has_foreground()) {
         hasMcStyle = true;
@@ -149,8 +159,12 @@ std::string getMcCodeFromTextStyle(fmt::text_style style) {
             }
         }
     }
-    if (style.has_background()) { hasMcStyle = true; }
-    if (hasMcStyle) { return res; }
+    if (style.has_background()) {
+        hasMcStyle = true;
+    }
+    if (hasMcStyle) {
+        return res;
+    }
     return "§r";
 }
 
@@ -173,7 +187,9 @@ std::string getAnsiCodeFromTextStyle(fmt::text_style style) {
 
 std::wstring str2wstr(std::string_view str, uint codePage) {
     int len = MultiByteToWideChar(codePage, 0, str.data(), (int)str.size(), nullptr, 0);
-    if (len == 0) { return {}; }
+    if (len == 0) {
+        return {};
+    }
     std::wstring wstr(len, L'\0');
     MultiByteToWideChar(codePage, 0, str.data(), (int)str.size(), wstr.data(), len);
     return wstr;
@@ -181,7 +197,9 @@ std::wstring str2wstr(std::string_view str, uint codePage) {
 
 std::string wstr2str(std::wstring_view str, uint codePage) {
     int len = WideCharToMultiByte(codePage, 0, str.data(), (int)str.size(), nullptr, 0, nullptr, nullptr);
-    if (len == 0) { return {}; }
+    if (len == 0) {
+        return {};
+    }
     std::string ret(len, '\0');
     WideCharToMultiByte(codePage, 0, str.data(), (int)str.size(), ret.data(), (int)ret.size(), nullptr, nullptr);
     return ret;
diff --git a/src/ll/api/utils/StringUtils.h b/src/ll/api/utils/StringUtils.h
index a024bfdf57..1f4468db1e 100644
--- a/src/ll/api/utils/StringUtils.h
+++ b/src/ll/api/utils/StringUtils.h
@@ -178,9 +178,15 @@ template <class T, auto f>
     char*       eptr;
     errnoRef       = 0;
     const auto ans = f(ptr, &eptr, base);
-    if (ptr == eptr) { throw std::invalid_argument("invalid svtonum argument"); }
-    if (errnoRef == ERANGE) { throw std::out_of_range("svtonum argument out of range"); }
-    if (idx) { *idx = static_cast<size_t>(eptr - ptr); }
+    if (ptr == eptr) {
+        throw std::invalid_argument("invalid svtonum argument");
+    }
+    if (errnoRef == ERANGE) {
+        throw std::out_of_range("svtonum argument out of range");
+    }
+    if (idx) {
+        *idx = static_cast<size_t>(eptr - ptr);
+    }
     return static_cast<T>(ans);
 }
 template <class T, auto f>
@@ -190,9 +196,15 @@ template <class T, auto f>
     char*       eptr;
     errnoRef       = 0;
     const auto ans = f(ptr, &eptr);
-    if (ptr == eptr) { throw std::invalid_argument("invalid svtonum argument"); }
-    if (errnoRef == ERANGE) { throw std::out_of_range("svtonum argument out of range"); }
-    if (idx) { *idx = static_cast<size_t>(eptr - ptr); }
+    if (ptr == eptr) {
+        throw std::invalid_argument("invalid svtonum argument");
+    }
+    if (errnoRef == ERANGE) {
+        throw std::out_of_range("svtonum argument out of range");
+    }
+    if (idx) {
+        *idx = static_cast<size_t>(eptr - ptr);
+    }
     return static_cast<T>(ans);
 }
 
diff --git a/src/ll/core/CrashLogger.cpp b/src/ll/core/CrashLogger.cpp
index c145d75228..55573bd07c 100644
--- a/src/ll/core/CrashLogger.cpp
+++ b/src/ll/core/CrashLogger.cpp
@@ -103,16 +103,24 @@ static void dumpSystemInfo() {
                 auto fxPtr = (RtlGetVersionPtr)::GetProcAddress(hMod, "RtlGetVersion");
                 if (fxPtr != nullptr) {
                     osVersionInfoW.dwOSVersionInfoSize = sizeof(osVersionInfoW);
-                    if (0 == fxPtr(&osVersionInfoW)) { return osVersionInfoW; }
+                    if (0 == fxPtr(&osVersionInfoW)) {
+                        return osVersionInfoW;
+                    }
                 }
             }
             return osVersionInfoW;
         }();
-        if (osVersionInfoW.dwMajorVersion == 0) { return "Unknown"; }
+        if (osVersionInfoW.dwMajorVersion == 0) {
+            return "Unknown";
+        }
         std::string osVersion =
             std::to_string(osVersionInfoW.dwMajorVersion) + "." + std::to_string(osVersionInfoW.dwMinorVersion);
-        if (osVersionInfoW.dwBuildNumber != 0) { osVersion += "." + std::to_string(osVersionInfoW.dwBuildNumber); }
-        if (osVersionInfoW.szCSDVersion[0] != 0) { osVersion += " " + wstr2str(osVersionInfoW.szCSDVersion); }
+        if (osVersionInfoW.dwBuildNumber != 0) {
+            osVersion += "." + std::to_string(osVersionInfoW.dwBuildNumber);
+        }
+        if (osVersionInfoW.szCSDVersion[0] != 0) {
+            osVersion += " " + wstr2str(osVersionInfoW.szCSDVersion);
+        }
         return osVersion;
     }());
     crashInfo.logger.info("  |Is Wine: {}", win_utils::isWine());
@@ -176,7 +184,9 @@ static void dumpSystemInfo() {
 static void dumpStacktrace(_CONTEXT const& c) {
     crashInfo.logger.info("Stacktrace:");
     auto str = stacktrace_utils::toString(error_info::stacktraceFromCurrExc(c));
-    for (auto& sv : splitByPattern(str, "\n")) { crashInfo.logger.info("  |{}", sv); }
+    for (auto& sv : splitByPattern(str, "\n")) {
+        crashInfo.logger.info("  |{}", sv);
+    }
 }
 
 static BOOL CALLBACK dumpModules(
@@ -201,7 +211,9 @@ static bool genMiniDumpFile(PEXCEPTION_POINTERS e) {
 
     auto hDumpFile =
         CreateFileW(dumpFilePath.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
-    if (hDumpFile == INVALID_HANDLE_VALUE || hDumpFile == nullptr) { throw error_info::getWinLastError(); }
+    if (hDumpFile == INVALID_HANDLE_VALUE || hDumpFile == nullptr) {
+        throw error_info::getWinLastError();
+    }
 
     MINIDUMP_EXCEPTION_INFORMATION dumpInfo;
     ZeroMemory(&dumpInfo, sizeof(MINIDUMP_EXCEPTION_INFORMATION));
@@ -274,13 +286,17 @@ static LONG unhandledExceptionFilter(_In_ struct _EXCEPTION_POINTERS* e) {
         crashInfo.logger.info("Exception:");
         {
             auto str = error_info::makeExceptionString(error_info::createExceptionPtr(*e->ExceptionRecord));
-            for (auto& sv : string_utils::splitByPattern(str, "\n")) { crashInfo.logger.info("  |{}", sv); }
+            for (auto& sv : string_utils::splitByPattern(str, "\n")) {
+                crashInfo.logger.info("  |{}", sv);
+            }
         }
         crashInfo.logger.info("");
         crashInfo.logger.info("Registers:");
         {
             auto str = stacktrace_utils::toString(*e->ContextRecord);
-            for (auto& sv : splitByPattern(str, "\n")) { crashInfo.logger.info("  |{}", sv); }
+            for (auto& sv : splitByPattern(str, "\n")) {
+                crashInfo.logger.info("  |{}", sv);
+            }
         }
         crashInfo.logger.info("");
         dumpStacktrace(*e->ContextRecord);
diff --git a/src/ll/core/LeviLamina.cpp b/src/ll/core/LeviLamina.cpp
index bbc42ee7cc..9a9f5666e2 100644
--- a/src/ll/core/LeviLamina.cpp
+++ b/src/ll/core/LeviLamina.cpp
@@ -72,7 +72,9 @@ void checkOtherBdsInstance() {
     PROCESSENTRY32     pe32;
     pe32.dwSize         = sizeof(PROCESSENTRY32);
     HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-    if (hProcessSnap == INVALID_HANDLE_VALUE) { return; }
+    if (hProcessSnap == INVALID_HANDLE_VALUE) {
+        return;
+    }
     if (Process32First(hProcessSnap, &pe32)) {
         do {
             if (pe32.th32ProcessID != GetCurrentProcessId()
@@ -109,12 +111,16 @@ void checkOtherBdsInstance() {
                     rewind(stdin);
                     input = static_cast<char>(getchar());
                     rewind(stdin);
-                    if (input == 'n' || input == 'N') { break; }
+                    if (input == 'n' || input == 'N') {
+                        break;
+                    }
                     if (input == 'y' || input == 'Y') {
                         TerminateProcess(handle, 1);
                         break;
                     }
-                    if (input == 'e' || input == 'E') { std::terminate(); }
+                    if (input == 'e' || input == 'E') {
+                        std::terminate();
+                    }
                 }
             }
             CloseHandle(handle);
@@ -203,7 +209,9 @@ extern void enableArrayTagBugFix();
 void setupBugFixes() {
     auto& bugfixSettings = ll::globalConfig.modules.tweak.bugfixes;
     using namespace ll::bugfix;
-    if (bugfixSettings.fixArrayTagCompareBug) { enableArrayTagBugFix(); }
+    if (bugfixSettings.fixArrayTagCompareBug) {
+        enableArrayTagBugFix();
+    }
 }
 
 void startCrashLogger() {
@@ -232,7 +240,9 @@ void leviLaminaMain() {
     ll::loadLeviConfig();
 
     // Update default language
-    if (ll::globalConfig.language != "system") { i18n::globalDefaultLocaleName = ll::globalConfig.language; }
+    if (ll::globalConfig.language != "system") {
+        i18n::globalDefaultLocaleName = ll::globalConfig.language;
+    }
 
     setupBugFixes();
     checkProtocolVersion();
@@ -243,7 +253,9 @@ void leviLaminaMain() {
 
     if (ll::globalConfig.modules.checkRunningBDS) checkOtherBdsInstance();
 
-    if (ll::globalConfig.modules.crashLogger.enabled) { startCrashLogger(); }
+    if (ll::globalConfig.modules.crashLogger.enabled) {
+        startCrashLogger();
+    }
 
     // Register Exit Event Handler.
     SetConsoleCtrlHandler(ConsoleExitHandler, true);
diff --git a/src/ll/core/form/FormHandler.cpp b/src/ll/core/form/FormHandler.cpp
index d153a15efe..66626ab06c 100644
--- a/src/ll/core/form/FormHandler.cpp
+++ b/src/ll/core/form/FormHandler.cpp
@@ -13,14 +13,20 @@ namespace ll::form::handler {
 void SimpleFormHandler::handle(Player& player, std::string const& data) const {
     int selected = data != "null" ? stoi(data) : -1;
     if (selected >= 0 && selected < (int)mButtonCallbacks.size()) {
-        if (mButtonCallbacks[selected]) { mButtonCallbacks[selected](player); }
+        if (mButtonCallbacks[selected]) {
+            mButtonCallbacks[selected](player);
+        }
+    }
+    if (mCallback) {
+        mCallback(player, selected);
     }
-    if (mCallback) { mCallback(player, selected); }
 }
 
 void CustomFormHandler::handle(Player& player, std::string const& data) const {
     if (data == "null") {
-        if (mCallback) { mCallback(player, {}); }
+        if (mCallback) {
+            mCallback(player, {});
+        }
         return;
     }
 
@@ -41,12 +47,16 @@ void CustomFormHandler::handle(Player& player, std::string const& data) const {
         for (size_t i = 0; i < mFormElements.size(); ++i) {
             auto& element = mFormElements[i];
             auto& value   = dataJson[i];
-            if (element->getType() == CustomFormElement::Type::Label) { continue; }
+            if (element->getType() == CustomFormElement::Type::Label) {
+                continue;
+            }
 
             result.emplace(element->mName, element->parseResult(value));
         }
 
-        if (mCallback) { mCallback(player, result); }
+        if (mCallback) {
+            mCallback(player, result);
+        }
     } catch (...) {
         ll::logger.error("Failed to parse CustomForm result");
         return;
@@ -55,7 +65,9 @@ void CustomFormHandler::handle(Player& player, std::string const& data) const {
 
 void ModalFormHandler::handle(Player& player, std::string const& data) const {
     bool selected = data == "true";
-    if (mCallback) { mCallback(player, selected); }
+    if (mCallback) {
+        mCallback(player, selected);
+    }
 }
 
 std::unordered_map<uint, std::unique_ptr<FormHandler>> formHandlers = {};
@@ -99,7 +111,9 @@ LL_AUTO_TYPED_INSTANCE_HOOK(
 
     if (!modalPacket.mFormCancelReason && modalPacket.mJSONResponse) {
         data = modalPacket.mJSONResponse.value().toStyledString();
-        if (data.ends_with('\n')) { data.pop_back(); }
+        if (data.ends_with('\n')) {
+            data.pop_back();
+        }
     }
 
     ll::form::handler::handleFormPacket(player, modalPacket.mFormId, data);
diff --git a/src/ll/core/tweak/ArrayTagBugFix.cpp b/src/ll/core/tweak/ArrayTagBugFix.cpp
index 0926f82e44..ed44525e45 100644
--- a/src/ll/core/tweak/ArrayTagBugFix.cpp
+++ b/src/ll/core/tweak/ArrayTagBugFix.cpp
@@ -13,7 +13,9 @@ LL_TYPED_INSTANCE_HOOK(
     bool,
     Tag const& other
 ) {
-    if (getId() != other.getId() || data.mSize != ((ByteArrayTag&)other).data.mSize) { return false; }
+    if (getId() != other.getId() || data.mSize != ((ByteArrayTag&)other).data.mSize) {
+        return false;
+    }
     return memcmp(data.mBuffer.get(), ((ByteArrayTag&)other).data.mBuffer.get(), data.mSize) == 0;
 }
 LL_TYPED_INSTANCE_HOOK(
@@ -25,7 +27,9 @@ LL_TYPED_INSTANCE_HOOK(
     bool,
     Tag const& other
 ) {
-    if (getId() != other.getId() || data.mSize != ((IntArrayTag&)other).data.mSize) { return false; }
+    if (getId() != other.getId() || data.mSize != ((IntArrayTag&)other).data.mSize) {
+        return false;
+    }
     return memcmp(data.mBuffer.get(), ((IntArrayTag&)other).data.mBuffer.get(), data.mSize * sizeof(int)) == 0;
 }
 void enableArrayTagBugFix() {
diff --git a/src/ll/core/tweak/BuiltinCommands.cpp b/src/ll/core/tweak/BuiltinCommands.cpp
index ce1df5aafb..1f3cdedfd7 100644
--- a/src/ll/core/tweak/BuiltinCommands.cpp
+++ b/src/ll/core/tweak/BuiltinCommands.cpp
@@ -67,7 +67,9 @@ class TeleportDimensionCommand : public Command {
         std::string names;
         for (auto& actor : actors) {
             std::string actorName = actor->getNameTag();
-            if (actorName.empty()) { actorName = actor->getTypeName(); }
+            if (actorName.empty()) {
+                actorName = actor->getTypeName();
+            }
             names.append(", ").append(actorName);
             actor->teleport(getTargetPos(ori, actor), (int)DimensionId);
             output.success();
@@ -182,12 +184,20 @@ void LLPluginInfoCommand(CommandOutput& output, std::string const& pluginName) {
         outs.emplace("Description", plugin->getManifest().description.value_or(""));
         outs.emplace("Version", "v" + plugin->getManifest().version.value_or(Version{}).to_string());
         if (plugin->getManifest().extraInfo)
-            for (auto& [k, v] : *plugin->getManifest().extraInfo) { outs.emplace(k, v); }
+            for (auto& [k, v] : *plugin->getManifest().extraInfo) {
+                outs.emplace(k, v);
+            }
         size_t width = 10;
-        for (auto& [k, v] : outs) { width = std::max(width, k.length()); }
-        for (auto& [k, v] : outs) { oss << "- §l" << std::setw((int64)width) << std::left << k << "§r: " << v << '\n'; }
+        for (auto& [k, v] : outs) {
+            width = std::max(width, k.length());
+        }
+        for (auto& [k, v] : outs) {
+            oss << "- §l" << std::setw((int64)width) << std::left << k << "§r: " << v << '\n';
+        }
         auto text = oss.str();
-        if (text.ends_with('\n')) { text.pop_back(); }
+        if (text.ends_with('\n')) {
+            text.pop_back();
+        }
         output.success(text, {});
     } else {
         output.error("ll.cmd.pluginInfo.error.pluginNotFound"_tr, pluginName);
diff --git a/src/ll/core/tweak/ModifyInfomation.cpp b/src/ll/core/tweak/ModifyInfomation.cpp
index e6f29c3f48..c843809f0c 100644
--- a/src/ll/core/tweak/ModifyInfomation.cpp
+++ b/src/ll/core/tweak/ModifyInfomation.cpp
@@ -87,10 +87,12 @@ LL_AUTO_STATIC_HOOK(
     va_list     va;
     va_start(va, pszFormat);
     auto bufferCount = _vscprintf(pszFormat, va);
-    if (bufferCount >= 0) { success = true; }
+    if (bufferCount >= 0) {
+        success = true;
+    }
     if (success && bufferCount > 0) {
         buffer = std::string(bufferCount, ' ');
-        vsprintf(buffer.data(), pszFormat, va);
+        vsprintf_s(buffer.data(), bufferCount, pszFormat, va);
     }
     va_end(va);
 
@@ -107,11 +109,15 @@ LL_AUTO_STATIC_HOOK(
     auto& logger = knownPriority ? loggerMap.at(priority) : serverLogger.warn;
 
     while (std::getline(iss, line)) {
-        if (line.ends_with('\n')) { line.pop_back(); }
+        if (line.ends_with('\n')) {
+            line.pop_back();
+        }
 
         if (!serverStarted) tryModifyServerStartInfo(line);
 
-        if (!knownPriority) { line = fmt::format("<LVL|{}> {}", priority, line); }
+        if (!knownPriority) {
+            line = fmt::format("<LVL|{}> {}", priority, line);
+        }
         logger(line);
     }
 }
@@ -141,24 +147,36 @@ LL_AUTO_STATIC_HOOK(CppOutputRedirectHook, HookPriority::Highest, "main", int, i
 
     ll::Logger               coutlogger("std::cout");
     ll::io::ofuncstream      coutfs{[&](std::string_view s) {
-        if (s.ends_with('\n')) { s.remove_suffix(1); }
-        if (s.empty()) { return; }
+        if (s.ends_with('\n')) {
+            s.remove_suffix(1);
+        }
+        if (s.empty()) {
+            return;
+        }
         coutlogger.warn(s);
     }};
     ll::io::StreamRedirector coutsr(std::cout, coutfs.rdbuf());
 
     ll::Logger               cloglogger("std::clog");
     ll::io::ofuncstream      clogfs{[&](std::string_view s) {
-        if (s.ends_with('\n')) { s.remove_suffix(1); }
-        if (s.empty()) { return; }
+        if (s.ends_with('\n')) {
+            s.remove_suffix(1);
+        }
+        if (s.empty()) {
+            return;
+        }
         cloglogger.error(s);
     }};
     ll::io::StreamRedirector clogsr(std::clog, clogfs.rdbuf());
 
     ll::Logger               cerrlogger("std::cerr");
     ll::io::ofuncstream      cerrfs{[&](std::string_view s) {
-        if (s.ends_with('\n')) { s.remove_suffix(1); }
-        if (s.empty()) { return; }
+        if (s.ends_with('\n')) {
+            s.remove_suffix(1);
+        }
+        if (s.empty()) {
+            return;
+        }
         cerrlogger.fatal(s);
     }};
     ll::io::StreamRedirector cerrsr(std::cerr, cerrfs.rdbuf());
@@ -178,8 +196,12 @@ enum class PrintFileType {
 };
 
 void redirectStdIo(std::string_view str, FILE* stream) {
-    if (str.ends_with('\n')) { str.remove_suffix(1); }
-    if (str.empty()) { return; }
+    if (str.ends_with('\n')) {
+        str.remove_suffix(1);
+    }
+    if (str.empty()) {
+        return;
+    }
     if (stream == stdout) {
         stdoutlogger.warn(str);
     } else {
@@ -209,11 +231,13 @@ LL_AUTO_STATIC_HOOK(
     }
     auto bufferCount = _vscprintf_l(format, locale, argList);
 
-    if (bufferCount <= 0) { return 0; }
+    if (bufferCount <= 0) {
+        return 0;
+    }
 
     auto buffer = std::string(bufferCount, ' ');
 
-    _vsprintf_l(buffer.data(), format, locale, argList);
+    _vsprintf_s_l(buffer.data(), bufferCount, format, locale, argList);
 
     redirectStdIo(buffer, stream);
 
@@ -231,7 +255,9 @@ LL_AUTO_STATIC_HOOK(
     _locale_t   locale,
     va_list     argList
 ) {
-    if (stream != stdout && stream != stderr) { return origin(options, stream, format, locale, argList); }
+    if (stream != stdout && stream != stderr) {
+        return origin(options, stream, format, locale, argList);
+    }
     return __stdio_common_vfprintf_s(options, stream, format, locale, argList);
 }
 
@@ -246,9 +272,13 @@ LL_AUTO_STATIC_HOOK(
     _locale_t   locale,
     va_list     argList
 ) {
-    if (stream != stdout && stream != stderr) { return origin(options, stream, format, locale, argList); }
+    if (stream != stdout && stream != stderr) {
+        return origin(options, stream, format, locale, argList);
+    }
     auto bufferCount = _vscprintf_p_l(format, locale, argList);
-    if (bufferCount <= 0) { return 0; }
+    if (bufferCount <= 0) {
+        return 0;
+    }
     auto buffer = std::string(bufferCount, ' ');
     _vsprintf_p_l(buffer.data(), bufferCount, format, locale, argList);
     redirectStdIo(buffer, stream);
@@ -261,7 +291,9 @@ LL_AUTO_STATIC_HOOK(StdioPutsRedirectHook, HookPriority::Highest, puts, int, cha
 }
 
 LL_AUTO_STATIC_HOOK(StdioFPutsRedirectHook, HookPriority::Highest, fputs, int, char const* str, FILE* stream) {
-    if (stream != stdout && stream != stderr) { return origin(str, stream); }
+    if (stream != stdout && stream != stderr) {
+        return origin(str, stream);
+    }
     redirectStdIo(str, stream);
     return 0;
 }
@@ -277,9 +309,13 @@ LL_AUTO_STATIC_HOOK(
     FILE*       stream
 ) {
     try {
-        if (stream != stdout && stream != stderr) { return origin(buffer, elementSize, elementCount, stream); }
+        if (stream != stdout && stream != stderr) {
+            return origin(buffer, elementSize, elementCount, stream);
+        }
         auto sbuffer = std::string((char const*)buffer, elementCount * elementSize);
         redirectStdIo(sbuffer, stream);
         return elementCount;
-    } catch (...) { return 0; }
+    } catch (...) {
+        return 0;
+    }
 }
diff --git a/src/ll/test/ConfigTest.cpp b/src/ll/test/ConfigTest.cpp
index 0a5d2d541e..526bad9a9b 100644
--- a/src/ll/test/ConfigTest.cpp
+++ b/src/ll/test/ConfigTest.cpp
@@ -1,15 +1,12 @@
-
-#include "ll/api/memory/Hook.h"
-#include "ll/core/LeviLamina.h"
-#include "mc/server/ServerInstance.h"
-
-#include "ll/api/Config.h"
-
 #include "nlohmann/json.hpp"
 
+#include "ll/api/Config.h"
+#include "ll/api/base/ErrorInfo.h"
 #include "ll/api/base/Version.h"
+#include "ll/api/memory/Hook.h"
+#include "ll/core/LeviLamina.h"
 
-#include "ll/api/base/ErrorInfo.h"
+#include "mc/server/ServerInstance.h"
 
 // #include "ll/api/schedule/Scheduler.h"
 // #include "ll/api/service/GlobalService.h"
@@ -80,7 +77,9 @@ LL_AUTO_TYPED_INSTANCE_HOOK(
             helloReflection,
             nlohmann::ordered_json::parse(R"({"version":""})", nullptr, false, true)
         );
-    } catch (...) { ll::error_info::printCurrentException(); }
+    } catch (...) {
+        ll::error_info::printCurrentException();
+    }
 
     // ll::logger.debug("{} for load config", ll::config::loadConfig(helloReflection, "plugins/Test/testconfig.json"));
     // ll::logger.debug("\n{}", ll::reflection::serialize<nlohmann::ordered_json>(helloReflection).dump(4));
diff --git a/src/ll/test/EventTest.cpp b/src/ll/test/EventTest.cpp
index 94dde88e60..0096ea96eb 100644
--- a/src/ll/test/EventTest.cpp
+++ b/src/ll/test/EventTest.cpp
@@ -16,6 +16,7 @@ class TestEventB : public ll::event::Event {
     std::string some       = "hello world";
     ~TestEventB() override = default;
 };
+
 class TestEvent1 : public TestEventB {
 public:
     static constexpr ll::event::EventId CustomEventId{"My custom Id"};
@@ -29,6 +30,7 @@ class TestEvent1 : public TestEventB {
         }();
     }
 };
+
 class TestEvent2 : public ll::event::Cancellable<TestEventB> {
 public:
     TestEvent2() { some = "TestEvent2 haha"; }
@@ -41,13 +43,12 @@ class TestEvent2 : public ll::event::Cancellable<TestEventB> {
         }();
     }
 };
+
 class TestEvent3 : public ll::event::Event {
 public:
 };
 
-
 using namespace ll::schedule;
-
 using namespace ll::chrono_literals;
 
 SystemTimeScheduler remover;
@@ -83,7 +84,9 @@ LL_AUTO_TYPED_INSTANCE_HOOK(
             ev.cancel();
             ll::logger.debug("I'm 2, this can cancel, now isCancelled: {}", ev.isCancelled());
 
-            if (times.load() == 5) { throw std::runtime_error("hello"); }
+            if (times.load() == 5) {
+                throw std::runtime_error("hello");
+            }
         },
         ll::event::EventPriority::High
     );
diff --git a/src/ll/test/Packet_test.cpp b/src/ll/test/Packet_test.cpp
index b84b2d628d..bf4df6e000 100644
--- a/src/ll/test/Packet_test.cpp
+++ b/src/ll/test/Packet_test.cpp
@@ -74,7 +74,9 @@ inline bool replaceString(
     if (exclude) startOffset += start.size();
     auto endOffset = end.empty() ? std::string::npos : content.find(end, startOffset);
 
-    if (endOffset != std::string::npos && !exclude) { endOffset += end.size(); }
+    if (endOffset != std::string::npos && !exclude) {
+        endOffset += end.size();
+    }
     content.replace(startOffset, endOffset - startOffset, str);
     return true;
 }
@@ -83,7 +85,9 @@ void autoGenerate() {
 
     std::string path = __FILE__;
 
-    if (!path.starts_with(LL_WORKSPACE_FOLDER)) { path = LL_WORKSPACE_FOLDER + path; }
+    if (!path.starts_with(LL_WORKSPACE_FOLDER)) {
+        path = LL_WORKSPACE_FOLDER + path;
+    }
 
     auto file = ll::utils::file_utils::readAllFile(path, false);
     if (!file) {
diff --git a/src/ll/test/PtrTest.cpp b/src/ll/test/PtrTest.cpp
index 9256ed1a5c..32d0dc9976 100644
--- a/src/ll/test/PtrTest.cpp
+++ b/src/ll/test/PtrTest.cpp
@@ -15,7 +15,9 @@
 
 auto test() {
     auto exists = BlockTypeRegistry::lookupByName("minecraft:stone");
-    if (exists) { std::cout << exists->getTypeName() << std::endl; }
+    if (exists) {
+        std::cout << exists->getTypeName() << std::endl;
+    }
     return exists;
 }
 
@@ -60,13 +62,17 @@ LL_AUTO_TYPED_INSTANCE_HOOK(
     try {
         char* pp = (char*)(0x123);
         *pp      = 'a';
-    } catch (...) { ll::error_info::printCurrentException(); }
+    } catch (...) {
+        ll::error_info::printCurrentException();
+    }
 
     try {
         int a = 0;
         int b = 2 / a;
         std::cout << "b = " << b << std::endl;
-    } catch (...) { ll::error_info::printCurrentException(); }
+    } catch (...) {
+        ll::error_info::printCurrentException();
+    }
 #if _HAS_CXX23
     // static ll::utils::stacktrace_utils::SymbolLoader sl{};
 #endif
diff --git a/src/ll/test/RecipesTest.cpp b/src/ll/test/RecipesTest.cpp
index 2e6de15589..6cdc098646 100644
--- a/src/ll/test/RecipesTest.cpp
+++ b/src/ll/test/RecipesTest.cpp
@@ -58,7 +58,9 @@ LL_AUTO_TYPED_INSTANCE_HOOK(
                     // ukj["Item"] = item.getFullItemName();
                     // ukj["Data"] = data;
                     std::string iname = item.getFullItemName();
-                    if (data != 32767) { iname += ":" + std::to_string(data); }
+                    if (data != 32767) {
+                        iname += ":" + std::to_string(data);
+                    }
                     rijson["BaseMap"].push_back(iname);
                     return false;
                 });
@@ -117,14 +119,18 @@ LL_AUTO_TYPED_INSTANCE_HOOK(
 
     for (auto& recipe : json["crafting_table"].items()) {
         for (auto& i : recipe.value()["RecipeIngredient"]) {
-            if (i["StackSize"] < 1) { continue; }
+            if (i["StackSize"] < 1) {
+                continue;
+            }
             std::string key;
             if (i.contains("BaseMap")) {
                 for (auto& name : i["BaseMap"]) {
                     auto& table = multitable[name];
                     for (auto item : recipe.value()["ResultItem"]) {
                         item.erase("Count");
-                        if (!table.contains(item)) { table.push_back(item); }
+                        if (!table.contains(item)) {
+                            table.push_back(item);
+                        }
                     }
                 }
             }
@@ -132,7 +138,9 @@ LL_AUTO_TYPED_INSTANCE_HOOK(
             auto& table = multitable[key];
             for (auto item : recipe.value()["ResultItem"]) {
                 item.erase("Count");
-                if (!table.contains(item)) { table.push_back(item); }
+                if (!table.contains(item)) {
+                    table.push_back(item);
+                }
             }
         }
     }
diff --git a/src/ll/test/TestDynamicCommand.cpp b/src/ll/test/TestDynamicCommand.cpp
index d9440e9255..17921aa2ce 100644
--- a/src/ll/test/TestDynamicCommand.cpp
+++ b/src/ll/test/TestDynamicCommand.cpp
@@ -91,7 +91,9 @@ void setupTestParamCommand() {
            CommandOrigin const&,
            CommandOutput&                                           output,
            std::unordered_map<std::string, DynamicCommand::Result>& results) {
-            for (auto& [name, result] : results) { output.success(result.toDebugString()); }
+            for (auto& [name, result] : results) {
+                output.success(result.toDebugString());
+            }
         },
         CommandPermissionLevel::Any
     );
@@ -249,14 +251,20 @@ void onEnumExecute(
         if (std::find(softEnumNames.begin(), softEnumNames.end(), enumName) != softEnumNames.end()) {
             found = true;
             output.success("§eSoft Enum §l{}§r§e Values:"_tr, enumName);
-            for (auto& val : ll::Global<CommandRegistry>->getSoftEnumValues(enumName)) { output.success(val); }
+            for (auto& val : ll::Global<CommandRegistry>->getSoftEnumValues(enumName)) {
+                output.success(val);
+            }
         }
         if (!found) output.error(R"(Enum or Soft Enum "{}" not found)", enumName);
     } else {
         output.success("§eEnum Names:");
-        for (auto& val : ll::Global<CommandRegistry>->getEnumNames()) { output.success(val); }
+        for (auto& val : ll::Global<CommandRegistry>->getEnumNames()) {
+            output.success(val);
+        }
         output.success("§eSoft Enum Names:");
-        for (auto& val : ll::Global<CommandRegistry>->getSoftEnumNames()) { output.success(val); }
+        for (auto& val : ll::Global<CommandRegistry>->getSoftEnumNames()) {
+            output.success(val);
+        }
     }
 }
 
diff --git a/src/ll/test/TestManager.cpp b/src/ll/test/TestManager.cpp
index 2771b4fcfc..15804ac823 100644
--- a/src/ll/test/TestManager.cpp
+++ b/src/ll/test/TestManager.cpp
@@ -15,7 +15,9 @@ void TestManager::initAllTests() {
             failed++;
             fmt::print("Test {0} init failed: {1}\n", test->getName(), result.message);
         }
-        if (status == TestStatus::NotStarted) { status = result.isPassed ? TestStatus::Running : TestStatus::Failed; }
+        if (status == TestStatus::NotStarted) {
+            status = result.isPassed ? TestStatus::Running : TestStatus::Failed;
+        }
     }
     fmt::print(
         "Initialized {0} tests, success {1}, failed {2}\n",
diff --git a/src/ll/test/TestManager.h b/src/ll/test/TestManager.h
index dbd9278012..c1d328c3cc 100644
--- a/src/ll/test/TestManager.h
+++ b/src/ll/test/TestManager.h
@@ -35,7 +35,7 @@ class TestManager {
 };
 
 template <class T>
-concept Testable = std::is_base_of<ll::test::Test, T>::value;
+concept Testable = std::is_base_of_v<ll::test::Test, T>;
 
 template <Testable T>
 class TestRegister {
diff --git a/src/ll/test/TestRegistryDimension.cpp b/src/ll/test/TestRegistryDimension.cpp
index f308b86001..e55b98204c 100644
--- a/src/ll/test/TestRegistryDimension.cpp
+++ b/src/ll/test/TestRegistryDimension.cpp
@@ -51,7 +51,8 @@ void printVfable(void* t) {
 #endif
     for (size_t i = 0; table[i] != nullptr; ++i) {
 #if _HAS_CXX23
-        logger.info("v table[{:02}] : {}", i, ll::utils::stacktrace_utils::toString(*(std::stacktrace_entry*)&table[i]));
+        logger
+            .info("v table[{:02}] : {}", i, ll::utils::stacktrace_utils::toString(*(std::stacktrace_entry*)&table[i]));
 #else
         logger.info("v table[{}] : {}", i, table[i]);
 #endif
diff --git a/xmake.lua b/xmake.lua
index 55fee2679b..8e02949b3a 100644
--- a/xmake.lua
+++ b/xmake.lua
@@ -55,13 +55,12 @@ target("LeviLamina")
     add_cxflags("/utf-8", "/permissive-", "/EHa", "/W4")
     add_defines(
         "UNICODE", "LL_EXPORT", "WIN32_LEAN_AND_MEAN",
-        "CPPHTTPLIB_OPENSSL_SUPPORT", "_AMD64_", "NOMINMAX",
-        "_CRT_SECURE_NO_WARNINGS"
+        "CPPHTTPLIB_OPENSSL_SUPPORT", "_AMD64_", "NOMINMAX"
     )
     add_shflags("/DELAYLOAD:bedrock_server.dll")
     add_files("src/**.cpp","src/**.rc")
     -- xmake-repo
-    add_packages("entt", "fmt", "gsl", "gtest", "leveldb", "magic_enum", "nlohmann_json", "rapidjson")
+    add_packages("entt", "fmt", "gsl", "gtest", "leveldb", "magic_enum", "nlohmann_json", "rapidjson", { public = true })
     -- liteldev-repo
     add_packages("pcg_cpp", "preloader", "symbolprovider", "ctre", "pfr")
     if has_config("localbdslibrary") then