diff --git a/src-test/server/ConfigTest.cpp b/src-test/server/ConfigTest.cpp
index 7dac417c06..4cd38ada9f 100644
--- a/src-test/server/ConfigTest.cpp
+++ b/src-test/server/ConfigTest.cpp
@@ -34,6 +34,7 @@
 #include "mc/world/actor/DataItem.h"
 
 #include "ll/api/base/Containers.h"
+#include "ll/api/data/IndirectValue.h"
 
 // [0, 8, 16, 96, 97, 98, 104, 136, 144, 160, 176, 184, 196, 208, 232, 248, 304, 328, 360, 392, 408]
 
diff --git a/src-test/server/ECSTest.cpp b/src-test/server/ECSTest.cpp
index 863c49b4e7..3d6c65b7e6 100644
--- a/src-test/server/ECSTest.cpp
+++ b/src-test/server/ECSTest.cpp
@@ -37,7 +37,7 @@
 namespace ll::test::ecstest {
 
 void registerTimingCommand() {
-    constexpr static size_t counttick = 100;
+    static constexpr size_t counttick = 100;
     auto&                   cmd =
         ::ll::command::CommandRegistrar::getInstance()
             .getOrCreateCommand("timing", "timing", CommandPermissionLevel::GameDirectors, CommandFlagValue::None);
diff --git a/src/ll/api/Expected.cpp b/src/ll/api/Expected.cpp
index 2d00d67cc5..fc1dd118a0 100644
--- a/src/ll/api/Expected.cpp
+++ b/src/ll/api/Expected.cpp
@@ -11,27 +11,32 @@
 
 namespace ll {
 #if defined(LL_DEBUG)
-struct ErrorInfoBase::Impl {
+struct DebugContext {
     Stacktrace stacktrace;
 };
-ErrorInfoBase::ErrorInfoBase() noexcept : impl(std::make_unique<Impl>(Stacktrace::current(1))) {}
+
+void* Error::createExtraData() noexcept { return new DebugContext{Stacktrace::current(1)}; }
+void  Error::destroyExtraData(void* ptr) noexcept { delete ((DebugContext*)ptr); }
+void* Error::copyExtraData(void* ptr) noexcept { return new DebugContext(*(DebugContext const*)(ptr)); }
+
 std::string Error::message() const noexcept {
-    if (!mInfo) {
+    if (!hasValue()) {
         return "success";
     }
-    auto res  = mInfo->message();
+    auto res  = dataPtr->message();
     res      += "\nexpected stacktrace:\n";
-    res      += stacktrace_utils::toString(mInfo->impl->stacktrace);
+    res      += stacktrace_utils::toString(reinterpret_cast<DebugContext*>(extraData)->stacktrace);
     return res;
 }
 
-struct ExceptionError : ErrorInfoBase {
+struct ExceptionError {
     std::exception_ptr exc;
     Stacktrace         stacktrace;
     ExceptionError(std::exception_ptr const& exc) noexcept
     : exc(exc),
       stacktrace(error_utils::stacktraceFromCurrentException()) {}
-    [[nodiscard]] std::string message() const noexcept override {
+
+    [[nodiscard]] std::string message() const noexcept {
         auto res = error_utils::makeExceptionString(exc);
         if (!stacktrace.empty()) {
             res += "\nexception stacktrace:\n";
@@ -41,19 +46,20 @@ struct ExceptionError : ErrorInfoBase {
     }
 };
 #else
-struct ErrorInfoBase::Impl {};
-ErrorInfoBase::ErrorInfoBase() noexcept {}
-std::string Error::message() const noexcept { return mInfo ? mInfo->message() : "success"; }
 
-struct ExceptionError : ErrorInfoBase {
+void* Error::createExtraData() noexcept { return nullptr; }
+void  Error::destroyExtraData(void* ptr) noexcept {}
+void* Error::copyExtraData(void* ptr) noexcept { return nullptr; }
+
+std::string Error::message() const noexcept { return hasValue() ? dataPtr->message() : "success"; }
+
+struct ExceptionError {
     std::exception_ptr exc;
     ExceptionError(std::exception_ptr const& exc) noexcept : exc(exc) {}
-    std::string message() const noexcept override { return error_utils::makeExceptionString(exc); }
+    std::string message() const noexcept { return error_utils::makeExceptionString(exc); }
 };
 #endif
 
-ErrorInfoBase::~ErrorInfoBase() = default;
-
 Unexpected makeExceptionError(std::exception_ptr const& exc) noexcept {
     auto err = error_utils::AnyExceptionRef(exc).tryGet<nonstd::bad_expected_access<Error>>();
     if (err) {
@@ -62,14 +68,13 @@ Unexpected makeExceptionError(std::exception_ptr const& exc) noexcept {
     return makeError<ExceptionError>(exc);
 }
 
-struct ErrorList : ErrorInfoBase {
-    std::vector<std::shared_ptr<ErrorInfoBase>> errors;
+struct ErrorList {
+    std::vector<Error> errors;
     ErrorList() noexcept = default;
-    [[nodiscard]] std::string message() const noexcept override {
+    [[nodiscard]] std::string message() const noexcept {
         std::string result;
-
         for (size_t i = 0; i < errors.size(); i++) {
-            result += errors[i]->message();
+            result += errors[i].message();
             if (i + 1 < errors.size()) {
                 result += '\n';
             }
@@ -79,8 +84,9 @@ struct ErrorList : ErrorInfoBase {
 };
 
 Error& Error::join(Error err) noexcept {
-    if (!*this) {
-        mInfo = std::move(err.mInfo);
+    if (!hasValue()) {
+        tidy();
+        move(std::move(err));
         return *this;
     }
     if (!err) {
@@ -90,18 +96,19 @@ Error& Error::join(Error err) noexcept {
         if (err.isA<ErrorList>()) {
             as<ErrorList>().errors.append_range(std::move(err.as<ErrorList>().errors));
         } else {
-            as<ErrorList>().errors.emplace_back(std::move(err.mInfo));
+            as<ErrorList>().errors.emplace_back(std::move(err));
         }
     } else {
         if (err.isA<ErrorList>()) {
             auto& list = err.as<ErrorList>();
-            list.errors.insert(list.errors.begin(), std::move(mInfo));
-            mInfo = std::move(err.mInfo);
+            list.errors.insert(list.errors.begin(), std::move(*this));
+            *this = std::move(err);
         } else {
-            auto list = std::make_unique<ErrorList>();
-            list->errors.emplace_back(std::move(mInfo));
-            list->errors.emplace_back(std::move(err.mInfo));
-            mInfo = std::move(list);
+            Error list(std::in_place_type<ErrorList>);
+            auto& vec = list.as<ErrorList>().errors;
+            vec.emplace_back(std::move(*this));
+            vec.emplace_back(std::move(err));
+            *this = std::move(list);
         }
     }
     return *this;
diff --git a/src/ll/api/Expected.h b/src/ll/api/Expected.h
index 067049568e..8b3e45a141 100644
--- a/src/ll/api/Expected.h
+++ b/src/ll/api/Expected.h
@@ -13,7 +13,9 @@
 #include <memory>
 #include <string_view>
 
+#include "ll/api/base/Concepts.h"
 #include "ll/api/base/Macro.h"
+#include "ll/api/data/AnyObjBase.h"
 #include "ll/api/io/LogLevel.h"
 
 #include "mc/server/commands/CommandOutputMessageType.h"
@@ -28,48 +30,150 @@ using Expected = ::nonstd::expected<T, ::ll::Error>;
 
 using Unexpected = ::nonstd::unexpected_type<::ll::Error>;
 
-class ErrorInfoBase {
-    friend Error;
-    struct Impl;
-    std::unique_ptr<Impl> impl;
+template <class T>
+concept IsErrorObj = requires(T t) {
+    requires requires {
+        { t.message() } -> concepts::IsString;
+    } || requires {
+        { t.what() } -> concepts::IsString;
+    };
+} || concepts::IsString<T>;
 
+class ErrorObjBase : public data::AnyObjBase {
 public:
-    LLAPI ErrorInfoBase() noexcept;
-    LLAPI virtual ~ErrorInfoBase();
+    static constexpr inline size_t errorSizeNumPtrs = 7;
+    static constexpr inline size_t smallObjSize     = ((errorSizeNumPtrs - 2) * sizeof(void*));
+
+    virtual ErrorObjBase*         copy(void* to) const    = 0;
+    virtual ErrorObjBase*         move(void* to) noexcept = 0;
+    virtual void                  tidy() noexcept         = 0;
+    virtual std::string           message() noexcept      = 0;
+    virtual std::type_info const& type() const noexcept   = 0;
+    virtual const void*           get() const noexcept    = 0;
+};
+template <IsErrorObj Err>
+class ErrorObj : public ErrorObjBase {
+    Err err;
+
+public:
+    static constexpr inline bool nothrowMove = std::is_nothrow_move_constructible_v<Err>;
+
+    template <class... Args>
+    constexpr explicit ErrorObj(Args&&... args) : err(std::forward<Args>(args)...) {}
+
+    template <class... Args>
+    static constexpr ErrorObjBase* construct(void* to, Args&&... args) {
+        return constructImpl<ErrorObj>(to, std::forward<Args>(args)...);
+    }
 
-    virtual std::string message() const noexcept = 0;
+    ErrorObjBase*         copy(void* to) const override { return constructImpl<ErrorObj>(to, err); }
+    ErrorObjBase*         move(void* to) noexcept override { return constructImpl<ErrorObj>(to, std::move(err)); }
+    void                  tidy() noexcept override { destroyImpl<ErrorObj>(this); }
+    std::type_info const& type() const noexcept override { return typeid(Err); }
+    void const*           get() const noexcept override { return std::addressof(err); }
+    std::string           message() noexcept override {
+        if constexpr (requires {
+                          { err.message() } -> concepts::IsString;
+                      }) {
+            return err.message();
+        } else if constexpr (requires {
+                                 { err.what() } -> concepts::IsString;
+                             }) {
+            return err.what();
+        } else {
+            return err;
+        }
+    }
 };
+
 class Error {
-    mutable std::unique_ptr<ErrorInfoBase> mInfo;
+    ErrorObjBase* dataPtr{};
+    void*         extraData{};
+    union {
+        std::max_align_t dummy;
+        char             soo[ErrorObjBase::smallObjSize];
+    };
+
+    constexpr bool isLarge() const noexcept { return dataPtr != static_cast<const void*>(&soo); }
+
+    constexpr bool hasValue() const noexcept { return dataPtr; }
+
+    LLAPI static void* createExtraData() noexcept;
+    LLAPI static void  destroyExtraData(void*) noexcept;
+    LLAPI static void* copyExtraData(void*) noexcept;
+
+    void tidy() noexcept {
+        destroyExtraData(extraData);
+        extraData = nullptr;
+        if (hasValue()) {
+            dataPtr->tidy();
+            dataPtr = nullptr;
+        }
+    }
+    void copy(Error const& other) {
+        extraData = copyExtraData(other.extraData);
+        if (other.hasValue()) {
+            dataPtr = other.dataPtr->copy(&soo);
+        }
+    }
+    constexpr void move(Error&& other) noexcept {
+        extraData       = other.extraData;
+        other.extraData = nullptr;
+        if (other.hasValue()) {
+            if (other.isLarge()) {
+                dataPtr       = other.dataPtr;
+                other.dataPtr = nullptr;
+            } else {
+                dataPtr = other.dataPtr->move(&soo);
+                other.tidy();
+            }
+        }
+    }
 
 public:
-    Error& operator=(Error&&) noexcept         = default;
-    Error& operator=(Error const&) noexcept    = delete;
-    [[nodiscard]] Error(Error&&) noexcept      = default;
-    [[nodiscard]] Error(Error const&) noexcept = delete;
+    constexpr Error() noexcept {}
+    ~Error() { tidy(); }
+
+    Error(Error const& other) { copy(other); }
+    Error& operator=(Error const& other) {
+        if (this != std::addressof(other)) {
+            tidy();
+            copy(other);
+        }
+        return *this;
+    }
 
-    LL_CONSTEXPR23 Error() noexcept  = default;
-    LL_CONSTEXPR23 ~Error() noexcept = default;
+    constexpr Error(Error&& other) noexcept { move(std::move(other)); }
+    constexpr Error& operator=(Error&& other) noexcept {
+        if (this != std::addressof(other)) {
+            tidy();
+            move(std::move(other));
+        }
+        return *this;
+    }
 
-    LL_CONSTEXPR23 Error(std::unique_ptr<ErrorInfoBase> i) noexcept : mInfo(std::move(i)) {}
+    template <IsErrorObj Err, class... Args>
+    Error(std::in_place_type_t<Err>, Args&&... args)
+    : extraData(createExtraData()),
+      dataPtr(ErrorObj<Err>::construct(&soo, std::forward<Args>(args)...)) {}
 
-    LL_CONSTEXPR23 Error(::nonstd::unexpected_type<::ll::Error> i) noexcept : Error(std::move(i.value())) {}
+    Error(::nonstd::unexpected_type<::ll::Error> i) noexcept : Error(std::move(i.value())) {}
 
-    LL_CONSTEXPR23 operator bool() const noexcept { return mInfo != nullptr; }
+    constexpr operator bool() const noexcept { return hasValue(); }
 
-    LL_CONSTEXPR23 operator Unexpected() noexcept {
-        return ::nonstd::make_unexpected<Error>(std::in_place, std::move(mInfo));
-    }
+    operator Unexpected() noexcept { return ::nonstd::make_unexpected<Error>(std::move(*this)); }
 
     LLNDAPI std::string message() const noexcept;
 
+    std::type_info const& type() const noexcept { return hasValue() ? dataPtr->type() : typeid(void); }
+
     template <class T>
-    LL_CONSTEXPR23 bool isA() noexcept {
-        return mInfo ? typeid(T) == typeid(mInfo.get()) : false;
+    constexpr bool isA() noexcept {
+        return typeid(T) == type();
     }
     template <class T>
-    LL_CONSTEXPR23 T& as() noexcept {
-        return *static_cast<T*>(mInfo.get());
+    constexpr T& as() noexcept {
+        return *(T*)(dataPtr->get());
     }
     LLAPI Error& join(Error) noexcept;
 
@@ -78,57 +182,39 @@ class Error {
     LLAPI Error const& log(CommandOutput&, CommandOutputMessageType = CommandOutputMessageType::Error) const noexcept;
 };
 
-struct StringError : ErrorInfoBase {
-    std::string str;
-    StringError(std::string str) : str(std::move(str)) {}
-    std::string message() const noexcept override { return str; }
-};
-struct ErrorCodeError : ErrorInfoBase {
-    std::error_code ec;
-    ErrorCodeError(std::error_code ec) : ec(ec) {}
-    std::string message() const noexcept override { return ec.message(); }
-};
 inline Unexpected forwardError(::ll::Error& err) noexcept { return ::nonstd::make_unexpected(std::move(err)); }
 
 inline Unexpected makeSuccessed() noexcept { return ::nonstd::make_unexpected(Error{}); }
 
-template <std::derived_from<::ll::ErrorInfoBase> T, class... Args>
+template <IsErrorObj Err, class... Args>
 inline Unexpected makeError(Args&&... args) noexcept {
-    return ::nonstd::make_unexpected<Error>(std::in_place, std::make_unique<T>(std::forward<Args>(args)...));
+    return ::nonstd::make_unexpected<Error>(std::in_place, std::in_place_type<Err>, std::forward<Args>(args)...);
 }
-inline Unexpected makeStringError(std::string str) noexcept { return makeError<StringError>(std::move(str)); }
+inline Unexpected makeStringError(std::string str) noexcept { return makeError<std::string>(std::move(str)); }
 
-inline Unexpected makeErrorCodeError(std::error_code ec) noexcept { return makeError<ErrorCodeError>(ec); }
+inline Unexpected makeErrorCodeError(std::error_code ec) noexcept { return makeError<std::error_code>(ec); }
 
-inline Unexpected makeErrorCodeError(std::errc ec) noexcept { return makeError<ErrorCodeError>(make_error_code(ec)); }
+inline Unexpected makeErrorCodeError(std::errc ec) noexcept { return makeErrorCodeError(make_error_code(ec)); }
 
 LLNDAPI Unexpected makeExceptionError(std::exception_ptr const& exc = std::current_exception()) noexcept;
 
 } // namespace ll
 
-namespace nonstd::expected_lite {
 template <>
-class bad_expected_access<::ll::Error> : public bad_expected_access<void> {
-    std::shared_ptr<::ll::Error> mError;
-    std::string                  mMessage;
+class nonstd::expected_lite::bad_expected_access<::ll::Error> : public bad_expected_access<void> {
+    ::ll::Error mError;
+    std::string mMessage;
 
 public:
-    explicit bad_expected_access(::ll::Error& e) noexcept
-    : mError(::std::make_shared<::ll::Error>(::std::move(e))),
-      mMessage(mError->message()) {}
+    explicit bad_expected_access(::ll::Error e) noexcept : mError(::std::move(e)), mMessage(mError.message()) {}
 
     char const* what() const noexcept override { return mMessage.c_str(); }
 
-    ::ll::Error& error() & { return *mError; }
+    ::ll::Error& error() & { return mError; }
 
-    ::ll::Error const& error() const& { return *mError; }
+    ::ll::Error const& error() const& { return mError; }
 
-    ::ll::Error&& error() && { return ::std::move(*mError); }
+    ::ll::Error&& error() && { return ::std::move(mError); }
 
-    ::ll::Error const&& error() const&& { return ::std::move(*mError); }
-};
-template <>
-struct error_traits<::ll::Error> {
-    static void rethrow(::ll::Error const& e) { throw bad_expected_access<::ll::Error>{const_cast<::ll::Error&>(e)}; }
+    ::ll::Error const&& error() const&& { return ::std::move(mError); }
 };
-} // namespace nonstd::expected_lite
diff --git a/src/ll/api/base/CompilerPredefine.h b/src/ll/api/base/CompilerPredefine.h
index 7781166089..119c0eb4d3 100644
--- a/src/ll/api/base/CompilerPredefine.h
+++ b/src/ll/api/base/CompilerPredefine.h
@@ -33,6 +33,10 @@
 #define LL_FORCEINLINE __forceinline
 #endif
 
+#ifndef LL_NOINLINE
+#define LL_NOINLINE __declspec(noinline)
+#endif
+
 #ifndef LL_CONSTEXPR23
 #define LL_CONSTEXPR23 _CONSTEXPR23
 #endif
@@ -252,6 +256,10 @@ using FileHandleT = void*;
 #define LL_FORCEINLINE inline __attribute__((always_inline))
 #endif
 
+#ifndef LL_NOINLINE
+#define LL_NOINLINE __attribute__((noinline))
+#endif
+
 #ifndef LL_CONSTEXPR23
 #if defined(__cpp_constexpr) && __cpp_constexpr >= 202211L
 #define LL_CONSTEXPR23 constexpr
diff --git a/src/ll/api/base/Containers.h b/src/ll/api/base/Containers.h
index e286226c65..af917b5f37 100644
--- a/src/ll/api/base/Containers.h
+++ b/src/ll/api/base/Containers.h
@@ -8,7 +8,6 @@
 #include <string_view>
 
 #include "ll/api/data/ConcurrentQueue.h"
-#include "ll/api/data/IndirectValue.h"
 
 #include "parallel_hashmap/btree.h"
 #include "parallel_hashmap/phmap.h"
@@ -110,27 +109,7 @@ using StringNodeMap = DenseNodeMap<::std::string, Value>;
 template <class Value>
 using SmallStringNodeMap = SmallDenseNodeMap<::std::string, Value>;
 
-
 template <typename T, typename A = std::allocator<T>>
 using ConcurrentQueue = data::concurrent_queue<T, A>;
 
-
-template <class T, class D = std::default_delete<T>>
-using Indirect = data::IndirectValue<T, data::defaultCopy<T>, D>;
-template <
-    class T,
-    class C =
-        std::conditional_t<traits::is_virtual_cloneable_v<T>, data::virtualCloneCopy<T>, data::polymorphicCopy<T>>,
-    class D = std::default_delete<T>>
-using Polymorphic = data::IndirectValue<T, C, D>;
-
-template <class T, class... Args>
-Indirect<T> makeIndirect(Args&&... args) {
-    return Indirect<T>(new T(std::forward<Args>(args)...));
-}
-template <class T, class... Args>
-Polymorphic<T> makePolymorphic(Args&&... args) {
-    return Polymorphic<T>(new T(std::forward<Args>(args)...));
-}
-
 } // namespace ll
diff --git a/src/ll/api/base/Meta.h b/src/ll/api/base/Meta.h
index 4a928fffff..8b27b96bf9 100644
--- a/src/ll/api/base/Meta.h
+++ b/src/ll/api/base/Meta.h
@@ -55,6 +55,7 @@ struct VisitStrategy<N, 0> {
     }
 };
 
+#ifndef LL_VISIT_CASE
 #define LL_VISIT_CASE(n)                                                                                               \
     case (n):                                                                                                          \
         if constexpr ((n) < N) {                                                                                       \
@@ -137,6 +138,7 @@ struct VisitStrategy<N, 4> {
 #undef LL_STAMP64
 #undef LL_STAMP16
 #undef LL_STAMP4
+#endif
 
 template <class Fn, class... Args>
 using VisitIndexResultT = decltype((std::declval<Fn>().template operator()<0>(std::declval<Args>()...)));
@@ -198,50 +200,50 @@ constexpr Ret visitIndex(size_t index, Fn&& fn, Args&&... args) {
     return Strategy::template impl<Ret>(index, std::forward<Fn>(fn), std::forward<Args>(args)...);
 }
 
-template <class... TL>
+template <class... Ts>
 class TypeList {
 public:
     template <class T>
-    static constexpr bool contains = (std::is_same_v<T, TL> || ...);
+    static constexpr bool contains = (std::is_same_v<T, Ts> || ...);
 
     template <template <class> class T>
-    static constexpr bool all = (T<TL>::value && ...);
+    static constexpr bool all = (T<Ts>::value && ...);
 
     template <template <class> class T>
-    static constexpr bool any = (T<TL>::value || ...);
+    static constexpr bool any = (T<Ts>::value || ...);
 
-    static constexpr size_t size = sizeof...(TL);
+    static constexpr size_t size = sizeof...(Ts);
 
     template <template <class> class W>
-    using wrap = TypeList<W<TL>...>;
+    using wrap = TypeList<W<Ts>...>;
 
     template <template <class> class M>
-    using map = TypeList<typename M<TL>::type...>;
+    using map = TypeList<typename M<Ts>::type...>;
 
     template <class T>
-    using push_back = TypeList<TL..., T>;
+    using push_back = TypeList<Ts..., T>;
 
     template <class T>
-    using push_front = TypeList<T, TL...>;
+    using push_front = TypeList<T, Ts...>;
 
     template <size_t N>
-    using get = traits::get_type_t<N + 1, void, TL...>;
+    using get = traits::get_type_t<N + 1, void, Ts...>;
 
     template <template <class...> class U>
-    using to = U<TL...>;
+    using to = U<Ts...>;
 
     template <class Func>
     static void constexpr forEach(Func&& func) {
-        unrollWithArgsNoIndex<TL...>(func);
+        unrollWithArgsNoIndex<Ts...>(func);
     }
 
     template <class Func>
     static void constexpr forEachIndexed(Func&& func) {
-        unrollWithArgs<TL...>(func);
+        unrollWithArgs<Ts...>(func);
     }
 
     template <class T>
-    static constexpr size_t index = traits::index_of<T, TL...>::value;
+    static constexpr size_t index = traits::index_of<T, Ts...>::value;
 };
 
 template <class Group, class T, auto Id = int64{}>
diff --git a/src/ll/api/base/TypeTraits.h b/src/ll/api/base/TypeTraits.h
index 45adb373d4..dfed2be9be 100644
--- a/src/ll/api/base/TypeTraits.h
+++ b/src/ll/api/base/TypeTraits.h
@@ -6,18 +6,18 @@
 
 namespace ll::traits {
 
-template <size_t N, class T, class... Types>
+template <size_t N, class T, class... Ts>
 struct get_type {
-    using type = typename get_type<N - 1, Types...>::type;
+    using type = typename get_type<N - 1, Ts...>::type;
 };
 
-template <class T, class... Types>
-struct get_type<0, T, Types...> {
+template <class T, class... Ts>
+struct get_type<0, T, Ts...> {
     using type = T;
 };
 
-template <size_t N, class... Types>
-using get_type_t = typename get_type<N, Types...>::type;
+template <size_t N, class... Ts>
+using get_type_t = typename get_type<N, Ts...>::type;
 
 template <class T, class U, class... Args>
 struct max_type {
@@ -40,27 +40,28 @@ struct index_of<T, U, Ts...> : std::integral_constant<size_t, 1 + index_of<T, Ts
 
 
 template <class>
-struct function_signature;
+struct function_traits;
 
 template <class Ret, class... Args>
-struct function_signature<Ret(Args...)> {
-    using type = Ret(Args...);
+struct function_traits<Ret(Args...)> {
+    using common_type = Ret(Args...);
 };
 
 template <class Ret, class... Args>
-struct function_signature<Ret (*)(Args...)> : function_signature<Ret(Args...)> {};
+struct function_traits<Ret (*)(Args...)> : function_traits<Ret(Args...)> {};
 
 template <class F>
-struct function_signature : function_signature<decltype(&F::operator())> {};
+struct function_traits : function_traits<decltype(&F::operator())> {};
 
 template <class Ret, class Cls, class... Args>
-struct function_signature<Ret (Cls::*)(Args...)> : function_signature<Ret(Args...)> {};
+struct function_traits<Ret (Cls::*)(Args...)> : function_traits<Ret(Args...)> {};
 
+#ifndef LL_BUILD_FUNCTION_SIGNATURE
 #define LL_BUILD_FUNCTION_SIGNATURE(...)                                                                               \
     template <class Ret, class Cls, class... Args>                                                                     \
-    struct function_signature<Ret (Cls::*)(Args...) __VA_ARGS__> : function_signature<Ret(Args...) __VA_ARGS__> {};    \
+    struct function_traits<Ret (Cls::*)(Args...) __VA_ARGS__> : function_traits<Ret(Args...) __VA_ARGS__> {};          \
     template <class Ret, class... Args>                                                                                \
-    struct function_signature<Ret(Args...) __VA_ARGS__> : function_signature<Ret(Args...)> {};
+    struct function_traits<Ret(Args...) __VA_ARGS__> : function_traits<Ret(Args...)> {};
 
 LL_BUILD_FUNCTION_SIGNATURE(const)
 LL_BUILD_FUNCTION_SIGNATURE(volatile)
@@ -86,9 +87,7 @@ LL_BUILD_FUNCTION_SIGNATURE(const&& noexcept)
 LL_BUILD_FUNCTION_SIGNATURE(volatile&& noexcept)
 LL_BUILD_FUNCTION_SIGNATURE(const volatile&& noexcept)
 #undef LL_BUILD_FUNCTION_SIGNATURE
-
-template <class T>
-using function_signature_t = typename function_signature<T>::type;
+#endif
 
 template <class T, class U>
 struct is_in_types;
diff --git a/src/ll/api/data/AnyBase.h b/src/ll/api/data/AnyBase.h
deleted file mode 100644
index cef0f0328e..0000000000
--- a/src/ll/api/data/AnyBase.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <type_traits>
-
-namespace ll::data {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4265)
-#endif
-class AnyBase {
-public:
-    static constexpr inline size_t smallObjectNumPtrs = 8;
-    static constexpr inline size_t smallObjectSize    = ((smallObjectNumPtrs - 1) * sizeof(void*));
-    template <class Data>
-    static constexpr bool isLarge = sizeof(Data) > smallObjectSize || alignof(Data) > alignof(std::max_align_t)
-                                 || !Data::nothrowMove;
-
-    AnyBase()                          = default;
-    AnyBase(const AnyBase&)            = delete;
-    AnyBase& operator=(const AnyBase&) = delete;
-
-    virtual AnyBase* copy(void* to) const    = 0;
-    virtual AnyBase* move(void* to) noexcept = 0;
-    virtual void     tidy() noexcept         = 0;
-};
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-} // namespace ll::data
diff --git a/src/ll/api/data/AnyFunction.h b/src/ll/api/data/AnyFunction.h
index 835772c6dd..5cc76f1bf2 100644
--- a/src/ll/api/data/AnyFunction.h
+++ b/src/ll/api/data/AnyFunction.h
@@ -8,14 +8,10 @@
 
 #include "ll/api/base/Macro.h"
 #include "ll/api/base/TypeTraits.h"
-#include "ll/api/data/AnyBase.h"
+#include "ll/api/data/AnyObjBase.h"
 
 namespace ll::data {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4265)
-#endif
-class AnyFunctionDataBase : public AnyBase {
+class AnyFunctionObjBase : public AnyObjBase {
 protected:
     template <class Arg>
     static auto getArg(std::any& any
@@ -35,17 +31,18 @@ class AnyFunctionDataBase : public AnyBase {
     }
 
 public:
-    virtual AnyFunctionDataBase* copy(void* to) const        = 0;
-    virtual AnyFunctionDataBase* move(void* to) noexcept     = 0;
-    virtual void                 tidy() noexcept             = 0;
-    virtual std::any             invoke(std::span<std::any>) = 0;
+    static constexpr inline size_t anyFnSizeNumPtrs = 8;
+    static constexpr inline size_t smallObjSize     = ((anyFnSizeNumPtrs - 1) * sizeof(void*));
+
+    virtual AnyFunctionObjBase* copy(void* to) const        = 0;
+    virtual AnyFunctionObjBase* move(void* to) noexcept     = 0;
+    virtual void                tidy() noexcept             = 0;
+    virtual std::any            invoke(std::span<std::any>) = 0;
 };
 template <class Fn, class Ret, class... Args>
-class AnyFunctionData : public AnyFunctionDataBase {
+class AnyFunctionObj : public AnyFunctionObjBase {
     Fn fn;
 
-    using Self = AnyFunctionData;
-
     template <std::size_t... I>
     std::any invokeImpl(std::span<std::any> args, std::index_sequence<I...>) {
         if constexpr (std::is_void_v<Ret>) {
@@ -59,66 +56,45 @@ class AnyFunctionData : public AnyFunctionDataBase {
 public:
     static constexpr inline bool nothrowMove = std::is_nothrow_move_constructible_v<Fn>;
 
-    template <class Fn>
-        requires(!std::is_same_v<Fn, AnyFunctionData>)
-    explicit AnyFunctionData(Fn&& fn) : fn(std::forward<Fn>(fn)) {}
+    template <class T>
+        requires(!std::is_same_v<T, AnyFunctionObj>)
+    constexpr explicit AnyFunctionObj(T&& fn) : fn(std::forward<T>(fn)) {}
 
     std::any invoke(std::span<std::any> args) override { return invokeImpl(args, std::index_sequence_for<Args...>{}); }
 
-    template <class Fn>
-    static AnyFunctionDataBase* construct(void* to, Fn&& v) {
-        if constexpr (isLarge<Self>) {
-            return ::new Self(std::forward<Fn>(v));
-        } else {
-            return ::new (to) Self(std::forward<Fn>(v));
-        }
+    template <class F>
+    static constexpr AnyFunctionObjBase* construct(void* to, F&& f) {
+        return constructImpl<AnyFunctionObj>(to, std::forward<F>(f));
     }
 
-    AnyFunctionDataBase* copy(void* to) const override {
-        if constexpr (isLarge<Self>) {
-            return ::new Self(fn);
-        } else {
-            return ::new (to) Self(fn);
-        }
-    }
-    AnyFunctionDataBase* move(void* to) noexcept override {
-        if constexpr (isLarge<Self>) {
-            return nullptr;
-        } else {
-            return ::new (to) Self(std::move(fn));
-        }
-    }
-    void tidy() noexcept override {
-        if constexpr (isLarge<Self>) {
-            delete this;
-        } else {
-            this->~Self();
-        }
-    }
+    AnyFunctionObjBase* copy(void* to) const override { return constructImpl<AnyFunctionObj>(to, fn); }
+    AnyFunctionObjBase* move(void* to) noexcept override { return constructImpl<AnyFunctionObj>(to, std::move(fn)); }
+    void                tidy() noexcept override { destroyImpl<AnyFunctionObj>(this); }
 };
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
+class AnyFunction {
+    AnyFunctionObjBase* dataPtr{};
+    union {
+        std::max_align_t dummy;
+        char             soo[AnyFunctionObjBase::smallObjSize];
+    };
 
-class alignas(std::max_align_t) AnyFunction {
-    AnyFunctionDataBase* dataPtr{};
-    char                 soo[AnyBase::smallObjectSize];
+    constexpr bool isLarge() const noexcept { return dataPtr != static_cast<const void*>(&soo); }
 
-    bool isLarge() const noexcept { return dataPtr != static_cast<const void*>(&soo); }
+    constexpr bool hasValue() const noexcept { return dataPtr; }
 
     void tidy() noexcept {
-        if (dataPtr) {
+        if (hasValue()) {
             dataPtr->tidy();
             dataPtr = nullptr;
         }
     }
     void copy(AnyFunction const& other) {
-        if (other) {
+        if (other.hasValue()) {
             dataPtr = other.dataPtr->copy(&soo);
         }
     }
     void move(AnyFunction&& other) noexcept {
-        if (other) {
+        if (other.hasValue()) {
             if (other.isLarge()) {
                 dataPtr       = other.dataPtr;
                 other.dataPtr = nullptr;
@@ -128,16 +104,6 @@ class alignas(std::max_align_t) AnyFunction {
             }
         }
     }
-    template <class Fn, class Ret, class... Args>
-    void construct(Fn&& fn) {
-        if constexpr (std::is_pointer_v<Fn> || traits::is_specialization_of_v<Fn, std::function>
-                      || std::is_member_pointer_v<Fn>) {
-            if (!fn) {
-                return;
-            }
-        }
-        dataPtr = AnyFunctionData<std::decay_t<Fn>, Ret, Args...>::construct(&soo, std::forward<Fn>(fn));
-    }
 
 public:
     AnyFunction() = default;
@@ -175,12 +141,18 @@ class alignas(std::max_align_t) AnyFunction {
     template <class Fn, class Ret, class... Args>
         requires(std::invocable<Fn, Args...>)
     AnyFunction(std::in_place_type_t<Ret(Args...)>, Fn&& fn) {
-        construct<Fn, Ret, Args...>(std::forward<Fn>(fn));
+        if constexpr (std::is_pointer_v<Fn> || traits::is_specialization_of_v<Fn, std::function>
+                      || std::is_member_pointer_v<Fn>) {
+            if (!fn) {
+                return;
+            }
+        }
+        dataPtr = AnyFunctionObj<std::decay_t<Fn>, Ret, Args...>::construct(&soo, std::forward<Fn>(fn));
     }
 
     template <class Fn>
     AnyFunction(Fn&& fn)
-    : AnyFunction(std::in_place_type<traits::function_signature_t<std::remove_cvref_t<Fn>>>, std::forward<Fn>(fn)) {}
+    : AnyFunction(std::in_place_type<typename traits::function_traits<Fn>::common_type>, std::forward<Fn>(fn)) {}
 
     std::any invoke(std::span<std::any> args) const { return dataPtr->invoke(args); }
 
@@ -190,7 +162,7 @@ class alignas(std::max_align_t) AnyFunction {
             std::array<std::any, sizeof...(Args)>{std::make_any<std::decay_t<Args>>(std::forward<Args>(args))...};
         return invoke(arr);
     }
-    explicit operator bool() const noexcept { return dataPtr; }
+    constexpr explicit operator bool() const noexcept { return hasValue(); }
 };
 [[nodiscard]] inline bool operator==(AnyFunction const& other, std::nullptr_t) noexcept { return !other; }
 
diff --git a/src/ll/api/data/AnyObjBase.h b/src/ll/api/data/AnyObjBase.h
new file mode 100644
index 0000000000..fcbfa5a561
--- /dev/null
+++ b/src/ll/api/data/AnyObjBase.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+namespace ll::data {
+class AnyObjBase {
+protected:
+    template <class Obj>
+    static constexpr bool isLarge = sizeof(Obj) > Obj::smallObjSize || alignof(Obj) > alignof(std::max_align_t)
+                                 || !Obj::nothrowMove;
+
+    template <class Obj, class... Args>
+    static constexpr Obj*
+    constructImpl(void* to, Args&&... args) noexcept(std::is_nothrow_constructible_v<Obj, Args...>) {
+        if constexpr (isLarge<Obj>) {
+            return ::new Obj(std::forward<Args>(args)...);
+        } else {
+            return ::new (to) Obj(std::forward<Args>(args)...);
+        }
+    }
+    template <class Obj>
+    static constexpr void destroyImpl(Obj* self) noexcept {
+        if constexpr (isLarge<Obj>) {
+            delete self;
+        } else {
+            self->~Obj();
+        }
+    }
+
+public:
+    AnyObjBase()                             = default;
+    AnyObjBase(const AnyObjBase&)            = delete;
+    AnyObjBase& operator=(const AnyObjBase&) = delete;
+
+    virtual ~AnyObjBase() = default;
+
+    virtual AnyObjBase* copy(void* to) const    = 0;
+    virtual AnyObjBase* move(void* to) noexcept = 0;
+    virtual void        tidy() noexcept         = 0;
+};
+} // namespace ll::data
diff --git a/src/ll/api/data/IndirectValue.h b/src/ll/api/data/IndirectValue.h
index 53f05a4ab6..d24052fbac 100644
--- a/src/ll/api/data/IndirectValue.h
+++ b/src/ll/api/data/IndirectValue.h
@@ -81,7 +81,7 @@ class IndirectValue {
     }
 
 public:
-    constexpr IndirectValue(std::nullptr_t) noexcept {}
+    constexpr IndirectValue(std::nullptr_t) noexcept : storage(zeroThenVariadicArgs) {}
 
     constexpr IndirectValue(T* ptr) noexcept : storage(zeroThenVariadicArgs, ptr) {}
 
@@ -181,3 +181,24 @@ struct hash<::ll::data::IndirectValue<T, C, D>> {
     std::size_t operator()(::ll::data::IndirectValue<T, C, D> const& value) const { return hash<T*>{}(value.get()); }
 };
 } // namespace std
+
+namespace ll {
+    template <class T, class D = std::default_delete<T>>
+using Indirect = data::IndirectValue<T, data::defaultCopy<T>, D>;
+template <
+    class T,
+    class C =
+        std::conditional_t<traits::is_virtual_cloneable_v<T>, data::virtualCloneCopy<T>, data::polymorphicCopy<T>>,
+    class D = std::default_delete<T>>
+using Polymorphic = data::IndirectValue<T, C, D>;
+
+template <class T, class... Args>
+Indirect<T> makeIndirect(Args&&... args) {
+    return Indirect<T>(new T(std::forward<Args>(args)...));
+}
+template <class T, class... Args>
+Polymorphic<T> makePolymorphic(Args&&... args) {
+    return Polymorphic<T>(new T(std::forward<Args>(args)...));
+}
+
+} // namespace ll
diff --git a/src/ll/api/data/TightPair.h b/src/ll/api/data/TightPair.h
index 76abd46058..483e0311a3 100644
--- a/src/ll/api/data/TightPair.h
+++ b/src/ll/api/data/TightPair.h
@@ -25,22 +25,22 @@ class TightPair final : private Base {
     : Base(),
       sec(std::forward<Ts2>(val2)...) {}
 
-    template <class Ts1, class... Ts2>
+    template <class T1, class... Ts2>
     constexpr TightPair(
         OneThenVariadicArgsT,
-        Ts1&& val1,
+        T1&& val1,
         Ts2&&... val2
-    ) noexcept(std::is_nothrow_constructible_v<Base, Ts1> && std::is_nothrow_constructible_v<Other, Ts2...>)
-    : Base(std::forward<Ts1>(val1)),
+    ) noexcept(std::is_nothrow_constructible_v<Base, T1> && std::is_nothrow_constructible_v<Other, Ts2...>)
+    : Base(std::forward<T1>(val1)),
       sec(std::forward<Ts2>(val2)...) {}
 
     constexpr first_type& first() noexcept { return *this; }
 
-    constexpr const first_type& first() const noexcept { return *this; }
+    constexpr first_type const& first() const noexcept { return *this; }
 
     constexpr second_type& second() noexcept { return sec; }
 
-    constexpr const second_type& second() const noexcept { return sec; }
+    constexpr second_type const& second() const noexcept { return sec; }
 };
 
 template <class Base, class Other>
@@ -60,21 +60,21 @@ class TightPair<Base, Other, false> final {
     : fst(),
       sec(std::forward<Ts2>(val2)...) {}
 
-    template <class Ts1, class... Ts2>
+    template <class T1, class... Ts2>
     constexpr TightPair(
         OneThenVariadicArgsT,
-        Ts1&& val1,
+        T1&& val1,
         Ts2&&... val2
-    ) noexcept(std::is_nothrow_constructible_v<Base, Ts1> && std::is_nothrow_constructible_v<Other, Ts2...>)
-    : fst(std::forward<Ts1>(val1)),
+    ) noexcept(std::is_nothrow_constructible_v<Base, T1> && std::is_nothrow_constructible_v<Other, Ts2...>)
+    : fst(std::forward<T1>(val1)),
       sec(std::forward<Ts2>(val2)...) {}
 
     constexpr first_type& first() noexcept { return fst; }
 
-    constexpr const first_type& first() const noexcept { return fst; }
+    constexpr first_type const& first() const noexcept { return fst; }
 
     constexpr second_type& second() noexcept { return sec; }
 
-    constexpr const second_type& second() const noexcept { return sec; }
+    constexpr second_type const& second() const noexcept { return sec; }
 };
 } // namespace ll::data
diff --git a/src/ll/api/io/Sink.h b/src/ll/api/io/Sink.h
index d16dd3408e..280c846a71 100644
--- a/src/ll/api/io/Sink.h
+++ b/src/ll/api/io/Sink.h
@@ -2,7 +2,7 @@
 
 #include <memory>
 
-#include "ll/api/base/Containers.h"
+#include "ll/api/data/IndirectValue.h"
 #include "ll/api/io/Formatter.h"
 
 namespace ll::io {
diff --git a/src/ll/api/memory/Memory.h b/src/ll/api/memory/Memory.h
index 76458fd285..7705034506 100644
--- a/src/ll/api/memory/Memory.h
+++ b/src/ll/api/memory/Memory.h
@@ -108,11 +108,11 @@ constexpr void destruct(void* ptr, ptrdiff_t off) noexcept {
     std::destroy_at(std::launder(reinterpret_cast<T*>((uintptr_t)((uintptr_t)ptr + off))));
 }
 
-template <class T, class... Types>
-constexpr auto construct(void* ptr, ptrdiff_t off, Types&&... args) {
+template <class T, class... Args>
+constexpr auto construct(void* ptr, ptrdiff_t off, Args&&... args) {
     return std::construct_at(
         std::launder(reinterpret_cast<T*>((uintptr_t)((uintptr_t)ptr + off))),
-        std::forward<Types>(args)...
+        std::forward<Args>(args)...
     );
 }
 
diff --git a/src/ll/api/memory/Signature.h b/src/ll/api/memory/Signature.h
index b24f7055cc..76da0ea19b 100644
--- a/src/ll/api/memory/Signature.h
+++ b/src/ll/api/memory/Signature.h
@@ -71,7 +71,7 @@ class Signature {
     [[nodiscard]] constexpr Signature(std::vector<SignatureElement> vec) : elements(std::move(vec)) {}
 
 public:
-    [[nodiscard]] constexpr static Signature parse(std::string_view str) {
+    [[nodiscard]] static constexpr Signature parse(std::string_view str) {
         std::vector<SignatureElement> elements;
         string_utils::splitByPattern(
             [&](std::string_view sv) {
diff --git a/src/ll/api/reflection/SerializationError.h b/src/ll/api/reflection/SerializationError.h
index b0b2d92dd0..b0ac10a9cf 100644
--- a/src/ll/api/reflection/SerializationError.h
+++ b/src/ll/api/reflection/SerializationError.h
@@ -6,7 +6,7 @@
 #include "ll/api/Expected.h"
 
 namespace ll::reflection {
-class SerializationError : public ErrorInfoBase {
+class SerializationError {
     std::string mField;
     std::string mMsg;
 
@@ -25,9 +25,7 @@ class SerializationError : public ErrorInfoBase {
             mMsg   = err.message();
         }
     }
-    std::string message() const noexcept override {
-        return fmt::format("Reflection error in field '{}':\n{}", mField, mMsg);
-    }
+    std::string message() const noexcept { return fmt::format("Reflection error in field '{}':\n{}", mField, mMsg); }
 };
 inline Unexpected makeSerMemberError(std::string_view name, Error& err) noexcept {
     return makeError<SerializationError>(fmt::format("{}.", name), std::move(err));
diff --git a/src/ll/api/service/ServiceManager.h b/src/ll/api/service/ServiceManager.h
index 1b823f365b..845435fe6e 100644
--- a/src/ll/api/service/ServiceManager.h
+++ b/src/ll/api/service/ServiceManager.h
@@ -13,7 +13,7 @@
 
 namespace ll::service {
 
-struct GetServiceError : ErrorInfoBase {
+struct GetServiceError {
     enum class ErrorType : char {
         NotExist        = 0,
         VersionMismatch = 1,
@@ -25,7 +25,7 @@ struct GetServiceError : ErrorInfoBase {
 
     GetServiceError(ErrorType code, size_t version = 0) : code(code), version(version) {}
 
-    LLAPI std::string message() const noexcept override;
+    LLAPI std::string message() const noexcept;
 };
 
 struct QueryServiceResult {
diff --git a/src/mc/deps/core/string/HashedString.h b/src/mc/deps/core/string/HashedString.h
index ebd63b1713..58f2a7e8c9 100644
--- a/src/mc/deps/core/string/HashedString.h
+++ b/src/mc/deps/core/string/HashedString.h
@@ -8,7 +8,7 @@ class HashedString {
     std::string                 str;
     mutable HashedString const* lastMatch;
 
-    [[nodiscard]] constexpr static uint64 computeHash(std::string_view str) {
+    [[nodiscard]] static constexpr uint64 computeHash(std::string_view str) {
         if (str.empty()) return 0;
         uint64 hash = 0xCBF29CE484222325ull;
         for (char s : str) {
diff --git a/src/mc/world/actor/DataItem.h b/src/mc/world/actor/DataItem.h
index 68dc8b8a8a..56fdb6bc94 100644
--- a/src/mc/world/actor/DataItem.h
+++ b/src/mc/world/actor/DataItem.h
@@ -31,16 +31,16 @@ class DataItem {
 
     template <typename T>
         requires(DataItem::TypeList::contains<std::remove_cvref_t<T>>)
-    [[nodiscard]] constexpr static std::unique_ptr<DataItem> create(ushort key, T&& value);
-    [[nodiscard]] constexpr static std::unique_ptr<DataItem> create(ushort key, bool value) {
+    [[nodiscard]] static constexpr std::unique_ptr<DataItem> create(ushort key, T&& value);
+    [[nodiscard]] static constexpr std::unique_ptr<DataItem> create(ushort key, bool value) {
         return create(key, (schar)value);
     }
     template <typename T>
         requires(DataItem::TypeList::contains<std::remove_cvref_t<T>>)
-    [[nodiscard]] constexpr static std::unique_ptr<DataItem> create(::ActorDataIDs key, T&& value) {
+    [[nodiscard]] static constexpr std::unique_ptr<DataItem> create(::ActorDataIDs key, T&& value) {
         return create(static_cast<std::underlying_type_t<::ActorDataIDs>>(key), std::forward<T>(value));
     }
-    [[nodiscard]] constexpr static std::unique_ptr<DataItem> create(::ActorDataIDs key, bool value) {
+    [[nodiscard]] static constexpr std::unique_ptr<DataItem> create(::ActorDataIDs key, bool value) {
         return create(key, (schar)value);
     }