From d6a93cdbab4b5fc3251a6e02a584070ad286dfbf Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Tue, 7 Apr 2026 12:40:54 +0200
Subject: [PATCH 01/14] Inspection first check in

---
 CMakeLists.txt                          |    4 +-
 Distribution/LuaBridge/LuaBridge.h      | 2474 +++++++++++++++++++++--
 Images/benchmarks.png                   |  Bin 170105 -> 168214 bytes
 Source/CMakeLists.txt                   |    1 +
 Source/LuaBridge/Inspect.h              | 1440 +++++++++++++
 Source/LuaBridge/LuaBridge.h            |    1 +
 Source/LuaBridge/detail/CFunctions.h    |    6 +
 Source/LuaBridge/detail/FunctionHints.h |  176 ++
 Source/LuaBridge/detail/LuaHelpers.h    |  102 +-
 Source/LuaBridge/detail/Namespace.h     |  239 ++-
 Tests/CMakeLists.txt                    |    5 +
 Tests/Source/InspectTests.cpp           |  565 ++++++
 amalgamate.py                           |    8 +-
 justfile                                |    3 +-
 14 files changed, 4769 insertions(+), 255 deletions(-)
 create mode 100644 Source/LuaBridge/Inspect.h
 create mode 100644 Source/LuaBridge/detail/FunctionHints.h
 create mode 100644 Tests/Source/InspectTests.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a79065db..1cf6acc8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,13 +13,13 @@ find_program (LCOV_EXECUTABLE lcov)
 find_program (GENHTML_EXECUTABLE genhtml)
 
 cmake_dependent_option (LUABRIDGE_TESTING "Build tests" ON "CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF)
+cmake_dependent_option (LUABRIDGE_SANITIZE "Sanitizer to enable (address, undefined, thread)" OFF "LUABRIDGE_TESTING" OFF)
 cmake_dependent_option (LUABRIDGE_COVERAGE "Enable coverage" OFF "LUABRIDGE_TESTING;FIND_EXECUTABLE;LCOV_EXECUTABLE;GENHTML_EXECUTABLE" OFF)
 cmake_dependent_option (LUABRIDGE_BENCHMARKS "Build benchmark executable" OFF "CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF)
-set (LUABRIDGE_SANITIZE "" CACHE STRING "Sanitizer to enable (address, undefined, thread)")
 
 add_subdirectory (Source)
 
-if (LUABRIDGE_TESTING)
+if (PROJECT_IS_TOP_LEVEL AND LUABRIDGE_TESTING)
     include (CTest)
     enable_testing()
     set (gtest_force_shared_crt ON CACHE BOOL "Use /MD and /MDd" FORCE)
diff --git a/Distribution/LuaBridge/LuaBridge.h b/Distribution/LuaBridge/LuaBridge.h
index b21f8723..a2d13260 100644
--- a/Distribution/LuaBridge/LuaBridge.h
+++ b/Distribution/LuaBridge/LuaBridge.h
@@ -10,6 +10,10 @@
 #include <array>
 #include <cassert>
 #include <cmath>
+#if defined(__has_include) && __has_include(<coroutine>)
+#include <coroutine>
+#endif
+
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
@@ -42,6 +46,26 @@
 #error LuaBridge 3 requires a compliant C++17 compiler, or C++17 has not been enabled !
 #endif
 
+#if defined(LUAU_FASTMATH_BEGIN)
+#define LUABRIDGE_ON_LUAU 1
+#elif defined(LUAJIT_VERSION)
+#define LUABRIDGE_ON_LUAJIT 1
+#elif defined(RAVI_OPTION_STRING2)
+#define LUABRIDGE_ON_RAVI 1
+#elif defined(LUA_VERSION_NUM)
+#define LUABRIDGE_ON_LUA 1
+#else
+#error "Lua headers must be included prior to LuaBridge ones"
+#endif
+
+#if !defined(LUABRIDGE_HAS_CXX20_COROUTINES)
+#if !defined(LUABRIDGE_DISABLE_CXX20_COROUTINES) && (__cplusplus >= 202002L || (defined(_MSC_VER) && _HAS_CXX20)) && !(LUABRIDGE_ON_LUAU || LUABRIDGE_ON_LUAJIT || LUABRIDGE_ON_RAVI || LUA_VERSION_NUM < 502)
+#define LUABRIDGE_HAS_CXX20_COROUTINES 1
+#else
+#define LUABRIDGE_HAS_CXX20_COROUTINES 0
+#endif
+#endif
+
 #if !defined(LUABRIDGE_HAS_EXCEPTIONS)
 #if defined(_MSC_VER)
 #if _CPPUNWIND || _HAS_EXCEPTIONS
@@ -78,18 +102,6 @@
 #define LUABRIDGE_NO_SANITIZE(x)
 #endif
 
-#if defined(LUAU_FASTMATH_BEGIN)
-#define LUABRIDGE_ON_LUAU 1
-#elif defined(LUAJIT_VERSION)
-#define LUABRIDGE_ON_LUAJIT 1
-#elif defined(RAVI_OPTION_STRING2)
-#define LUABRIDGE_ON_RAVI 1
-#elif defined(LUA_VERSION_NUM)
-#define LUABRIDGE_ON_LUA 1
-#else
-#error "Lua headers must be included prior to LuaBridge ones"
-#endif
-
 #if defined(__OBJC__)
 #define LUABRIDGE_ON_OBJECTIVE_C 1
 #endif
@@ -1021,6 +1033,41 @@ void* lua_newuserdata_aligned(lua_State* L, Args&&... args)
     return pointer;
 }
 
+inline int lua_resume_x(lua_State* L, lua_State* from, int nargs, int* nresults = nullptr)
+{
+#if LUABRIDGE_ON_LUAJIT || LUA_VERSION_NUM == 501
+    unused(from);
+    int status = lua_resume(L, nargs);
+    if (nresults)
+        *nresults = lua_gettop(L);
+    return status;
+#elif LUABRIDGE_ON_LUAU || LUABRIDGE_ON_RAVI || LUA_VERSION_NUM < 504
+    int status = lua_resume(L, from, nargs);
+    if (nresults)
+        *nresults = lua_gettop(L);
+    return status;
+#else
+    int nr = 0;
+    int status = lua_resume(L, from, nargs, &nr);
+    if (nresults)
+        *nresults = nr;
+    return status;
+#endif
+}
+
+inline bool lua_isyieldable_x(lua_State* L)
+{
+#if LUABRIDGE_ON_LUAJIT || LUA_VERSION_NUM == 501 || LUABRIDGE_ON_LUAU
+    unused(L);
+    return false;
+#elif LUA_VERSION_NUM < 503
+    unused(L);
+    return true; 
+#else
+    return lua_isyieldable(L) != 0;
+#endif
+}
+
 [[noreturn]] inline void raise_lua_error(lua_State* L, const char* fmt, ...)
 {
     va_list argp;
@@ -1179,7 +1226,11 @@ enum class ErrorCode
 
     InvalidTypeCast,
 
-    InvalidTableSizeInCast
+    InvalidTableSizeInCast,
+
+    CoroutineYieldFromNonCoroutine,
+
+    CoroutineAlreadyDone
 };
 
 namespace detail {
@@ -1220,6 +1271,12 @@ struct ErrorCategory : std::error_category
         case ErrorCode::InvalidTableSizeInCast:
             return "The lua table has different size than expected";
 
+        case ErrorCode::CoroutineYieldFromNonCoroutine:
+            return "Cannot yield from a non-coroutine Lua state";
+
+        case ErrorCode::CoroutineAlreadyDone:
+            return "The Lua coroutine has already finished execution";
+
         default:
             return "Unknown error";
         }
@@ -6008,78 +6065,6 @@ inline void dumpState(lua_State* L, unsigned maxDepth = 1, std::ostream& stream
 
 // End File: Source/LuaBridge/Dump.h
 
-// Begin File: Source/LuaBridge/List.h
-
-namespace luabridge {
-
-template <class T>
-struct Stack<std::list<T>>
-{
-    using Type = std::list<T>;
-    
-    [[nodiscard]] static Result push(lua_State* L, const Type& list)
-    {
-#if LUABRIDGE_SAFE_STACK_CHECKS
-        if (! lua_checkstack(L, 3))
-            return makeErrorCode(ErrorCode::LuaStackOverflow);
-#endif
-
-        StackRestore stackRestore(L);
-
-        lua_createtable(L, static_cast<int>(list.size()), 0);
-
-        auto it = list.cbegin();
-        for (lua_Integer tableIndex = 1; it != list.cend(); ++tableIndex, ++it)
-        {
-            lua_pushinteger(L, tableIndex);
-
-            auto result = Stack<T>::push(L, *it);
-            if (! result)
-                return result;
-
-            lua_settable(L, -3);
-        }
-
-        stackRestore.reset();
-        return {};
-    }
-
-    [[nodiscard]] static TypeResult<Type> get(lua_State* L, int index)
-    {
-        if (!lua_istable(L, index))
-            return makeErrorCode(ErrorCode::InvalidTypeCast);
-
-        const StackRestore stackRestore(L);
-
-        Type list;
-
-        int absIndex = lua_absindex(L, index);
-        lua_pushnil(L);
-
-        while (lua_next(L, absIndex) != 0)
-        {
-            auto item = Stack<T>::get(L, -1);
-            if (! item)
-                return makeErrorCode(ErrorCode::InvalidTypeCast);
-
-            list.emplace_back(*item);
-            lua_pop(L, 1);
-        }
-
-        return list;
-    }
-
-    [[nodiscard]] static bool isInstance(lua_State* L, int index)
-    {
-        return lua_istable(L, index);
-    }
-};
-
-} 
-
-
-// End File: Source/LuaBridge/List.h
-
 // Begin File: Source/LuaBridge/detail/FlagSet.h
 
 namespace luabridge {
@@ -7928,6 +7913,12 @@ struct OverloadEntry
 
     int arity;           
     TypeChecker checker; 
+
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+    std::string returnType;                
+    std::vector<std::string> paramTypes;   
+    std::vector<std::string> paramHints;   
+#endif
 };
 
 struct OverloadSet
@@ -8822,137 +8813,1985 @@ struct container_forwarder
 
 // End File: Source/LuaBridge/detail/CFunctions.h
 
-// Begin File: Source/LuaBridge/detail/Enum.h
+// Begin File: Source/LuaBridge/Inspect.h
 
 namespace luabridge {
 
-template <class T, T... Values>
-struct Enum
-{
-    static_assert(std::is_enum_v<T>);
+struct NamespaceInspectInfo;
+struct ClassInspectInfo;
+class InspectVisitor;
 
-    using Type = std::underlying_type_t<T>;
+void accept(const NamespaceInspectInfo& ns, InspectVisitor& v);
+void accept(const ClassInspectInfo& cls, InspectVisitor& v);
 
-    [[nodiscard]] static Result push(lua_State* L, T value)
-    {
-        return Stack<Type>::push(L, static_cast<Type>(value));
-    }
+enum class MemberKind
+{
+    Method,
+    StaticMethod,
+    Property,
+    ReadOnlyProperty,
+    StaticProperty,
+    StaticReadOnlyProperty,
+    Constructor,
+    Metamethod,
+};
 
-    [[nodiscard]] static TypeResult<T> get(lua_State* L, int index)
-    {
-        const auto result = Stack<Type>::get(L, index);
-        if (! result)
-            return result.error();
+struct ParamInfo
+{
+    std::string typeName; 
+    std::string hint;     
+};
 
-        if constexpr (sizeof...(Values) > 0)
-        {
-            constexpr Type values[] = { static_cast<Type>(Values)... };
-            for (std::size_t i = 0; i < sizeof...(Values); ++i)
-            {
-                if (values[i] == *result)
-                    return static_cast<T>(*result);
-            }
+struct OverloadInfo
+{
+    std::string returnType;        
+    std::vector<ParamInfo> params; 
+    bool isConst = false;          
+};
 
-            return makeErrorCode(ErrorCode::InvalidTypeCast);
-        }
-        else
-        {
-            return static_cast<T>(*result);
-        }
-    }
+struct MemberInfo
+{
+    std::string name;
+    MemberKind kind = MemberKind::Method;
+    std::vector<OverloadInfo> overloads; 
+};
 
-    [[nodiscard]] static bool isInstance(lua_State* L, int index)
-    {
-        return lua_type(L, index) == LUA_TNUMBER;
-    }
+struct ClassInspectInfo
+{
+    std::string name;
+    std::vector<std::string> baseClasses; 
+    std::vector<MemberInfo> members;
+
+    void accept(InspectVisitor& v) const;
 };
 
-} 
+struct NamespaceInspectInfo
+{
+    std::string name;
+    std::vector<MemberInfo> freeMembers;                  
+    std::vector<ClassInspectInfo> classes;
+    std::vector<NamespaceInspectInfo> subNamespaces;
 
+    void accept(InspectVisitor& v) const;
+};
 
-// End File: Source/LuaBridge/detail/Enum.h
+class InspectVisitor
+{
+public:
+    virtual ~InspectVisitor() = default;
 
-// Begin File: Source/LuaBridge/detail/Globals.h
+    virtual void beginNamespace(const NamespaceInspectInfo& 
+) {}
+    virtual void endNamespace(const NamespaceInspectInfo& 
+) {}
+    virtual void visitFreeMember(const NamespaceInspectInfo& 
+, const MemberInfo& 
+) {}
 
-namespace luabridge {
+    virtual void beginClass(const ClassInspectInfo& 
+) {}
+    virtual void endClass(const ClassInspectInfo& 
+) {}
+    virtual void visitMember(const ClassInspectInfo& 
+, const MemberInfo& 
+) {}
+};
 
-template <class T>
-TypeResult<T> getGlobal(lua_State* L, const char* name)
+inline void accept(const NamespaceInspectInfo& ns, InspectVisitor& v)
 {
-    lua_getglobal(L, name);
+    v.beginNamespace(ns);
+    for (const auto& m : ns.freeMembers)
+        v.visitFreeMember(ns, m);
+    for (const auto& cls : ns.classes)
+        accept(cls, v);
+    for (const auto& sub : ns.subNamespaces)
+        accept(sub, v);
+    v.endNamespace(ns);
+}
 
-    auto result = luabridge::Stack<T>::get(L, -1);
+inline void accept(const ClassInspectInfo& cls, InspectVisitor& v)
+{
+    v.beginClass(cls);
+    for (const auto& m : cls.members)
+        v.visitMember(cls, m);
+    v.endClass(cls);
+}
 
-    lua_pop(L, 1);
+inline void ClassInspectInfo::accept(InspectVisitor& v) const { luabridge::accept(*this, v); }
+inline void NamespaceInspectInfo::accept(InspectVisitor& v) const { luabridge::accept(*this, v); }
 
-    return result;
-}
+namespace detail {
 
-template <class T>
-bool setGlobal(lua_State* L, T&& t, const char* name)
+inline std::set<std::string> collectTableKeys(lua_State* L, int tableIdx)
 {
-    if (auto result = push(L, std::forward<T>(t)))
+    std::set<std::string> keys;
+    tableIdx = lua_absindex(L, tableIdx);
+    lua_pushnil(L);
+    while (lua_next(L, tableIdx))
     {
-        lua_setglobal(L, name);
-        return true;
+        if (lua_type(L, -2) == LUA_TSTRING)
+            keys.insert(lua_tostring(L, -2));
+        lua_pop(L, 1); 
     }
+    return keys;
+}
 
-    return false;
+inline std::string stripConst(const char* name)
+{
+    std::string s = name ? name : "";
+    if (s.substr(0, 6) == "const ")
+        s = s.substr(6);
+    return s;
 }
 
-} 
+inline std::vector<OverloadInfo> getOverloadInfos(lua_State* L, int funcIdx)
+{
+    funcIdx = lua_absindex(L, funcIdx);
 
+    if (!lua_isfunction(L, funcIdx))
+        return { OverloadInfo{} };
 
-// End File: Source/LuaBridge/detail/Globals.h
+    const char* uv1name = lua_getupvalue(L, funcIdx, 1);
+    if (uv1name == nullptr)
+    {
+        
+        return { OverloadInfo{} };
+    }
 
-// Begin File: Source/LuaBridge/detail/LuaRef.h
+    bool isOverloadSet = isfulluserdata(L, -1);
+    lua_pop(L, 1); 
 
-namespace luabridge {
+    if (!isOverloadSet)
+    {
+        
+        return { OverloadInfo{} };
+    }
 
-template <class Signature>
-class LuaFunction;
+    const char* uv2name = lua_getupvalue(L, funcIdx, 2);
+    bool hasTable = (uv2name != nullptr) && lua_istable(L, -1);
+    if (uv2name != nullptr)
+        lua_pop(L, 1); 
 
-struct LuaNil
-{
-};
+    if (!hasTable)
+        return { OverloadInfo{} };
 
-template <>
-struct Stack<LuaNil>
-{
-    [[nodiscard]] static Result push(lua_State* L, const LuaNil&)
+    lua_getupvalue(L, funcIdx, 1);
+    auto* overload_set = align<OverloadSet>(lua_touserdata(L, -1));
+    lua_pop(L, 1);
+
+    if (!overload_set || overload_set->entries.empty())
+        return { OverloadInfo{} };
+
+    std::vector<OverloadInfo> result;
+    result.reserve(overload_set->entries.size());
+
+    for (const auto& entry : overload_set->entries)
     {
-#if LUABRIDGE_SAFE_STACK_CHECKS
-        if (! lua_checkstack(L, 1))
-            return makeErrorCode(ErrorCode::LuaStackOverflow);
+        OverloadInfo info;
+
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+        info.returnType = entry.returnType;
+        for (std::size_t i = 0; i < entry.paramTypes.size(); ++i)
+        {
+            ParamInfo p;
+            p.typeName = entry.paramTypes[i];
+            if (i < entry.paramHints.size())
+                p.hint = entry.paramHints[i];
+            info.params.push_back(std::move(p));
+        }
+#else
+        
+        if (entry.arity >= 0)
+        {
+            for (int i = 0; i < entry.arity; ++i)
+                info.params.push_back(ParamInfo{});
+        }
 #endif
 
-        lua_pushnil(L);
-        return {};
+        result.push_back(std::move(info));
     }
 
-    [[nodiscard]] static bool isInstance(lua_State* L, int index)
-    {
-        return lua_type(L, index) == LUA_TNIL;
-    }
-};
+    return result;
+}
 
-template <class Impl, class LuaRef>
-class LuaRefBase
+inline bool isClassStaticTable(lua_State* L, int tableIdx)
 {
-protected:
-    friend struct Stack<LuaRef>;
+    tableIdx = lua_absindex(L, tableIdx);
 
-    struct FromStack
-    {
-    };
+    if (!lua_getmetatable(L, tableIdx)) 
+        return false;
 
-    LuaRefBase(lua_State* L) noexcept
-        : m_L(L)
+    lua_rawgetp(L, -1, getClassKey()); 
+    bool result = lua_istable(L, -1);
+    lua_pop(L, 1); 
+
+    if (!result)
     {
-        LUABRIDGE_ASSERT(L != nullptr);
+        lua_pop(L, 1); 
+        return false;
     }
 
-    int createRef() const
+    return true;
+}
+
+inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
+{
+    stIdx = lua_absindex(L, stIdx);
+
+    int mtIdx = lua_absindex(L, -1);
+
+    lua_rawgetp(L, mtIdx, getClassKey());
+    int clIdx = lua_absindex(L, -1);
+
+    ClassInspectInfo cls;
+
+    lua_rawgetp(L, clIdx, getTypeKey());
+    if (lua_isstring(L, -1))
+        cls.name = stripConst(lua_tostring(L, -1));
+    lua_pop(L, 1);
+
+    lua_rawgetp(L, clIdx, getParentKey());
+    if (lua_istable(L, -1))
+    {
+        int parIdx = lua_absindex(L, -1);
+        int len = static_cast<int>(luaL_len(L, parIdx));
+        for (int i = 1; i <= len; ++i)
+        {
+            lua_rawgeti(L, parIdx, i);
+            lua_rawgetp(L, -1, getTypeKey());
+            if (lua_isstring(L, -1))
+            {
+                std::string baseName = stripConst(lua_tostring(L, -1));
+                if (!baseName.empty() && baseName != cls.name)
+                    cls.baseClasses.push_back(std::move(baseName));
+            }
+            lua_pop(L, 2); 
+        }
+    }
+    lua_pop(L, 1); 
+
+    std::set<std::string> instPropget;
+    lua_rawgetp(L, clIdx, getPropgetKey());
+    if (lua_istable(L, -1))
+        instPropget = collectTableKeys(L, -1);
+    lua_pop(L, 1);
+
+    std::set<std::string> instPropsetReal;
+    lua_rawgetp(L, clIdx, getPropsetKey());
+    if (lua_istable(L, -1))
+    {
+        int psIdx = lua_absindex(L, -1);
+        for (const auto& k : instPropget)
+        {
+            lua_getfield(L, psIdx, k.c_str());
+            if (lua_isfunction(L, -1))
+            {
+                lua_CFunction fn = lua_tocfunction(L, -1);
+                if (fn != &detail::read_only_error)
+                    instPropsetReal.insert(k);
+            }
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1);
+
+    for (const auto& propName : instPropget)
+    {
+        MemberInfo m;
+        m.name = propName;
+        m.kind = instPropsetReal.count(propName) ? MemberKind::Property : MemberKind::ReadOnlyProperty;
+        m.overloads.push_back(OverloadInfo{});
+        cls.members.push_back(std::move(m));
+    }
+
+    static const std::set<std::string> skipKeys{ "__index", "__newindex", "__metatable" };
+
+    lua_pushnil(L);
+    while (lua_next(L, clIdx))
+    {
+        if (lua_type(L, -2) == LUA_TSTRING)
+        {
+            std::string key = lua_tostring(L, -2);
+            if (!skipKeys.count(key) && !instPropget.count(key))
+            {
+                if (lua_isfunction(L, -1) || lua_isuserdata(L, -1))
+                {
+                    MemberInfo m;
+                    m.name = key;
+                    m.kind = (key.size() >= 2 && key[0] == '_' && key[1] == '_')
+                        ? MemberKind::Metamethod
+                        : MemberKind::Method;
+                    m.overloads = getOverloadInfos(L, -1);
+                    cls.members.push_back(std::move(m));
+                }
+            }
+        }
+        lua_pop(L, 1); 
+    }
+
+    std::set<std::string> stPropget;
+    lua_rawgetp(L, mtIdx, getPropgetKey());
+    if (lua_istable(L, -1))
+        stPropget = collectTableKeys(L, -1);
+    lua_pop(L, 1);
+
+    std::set<std::string> stPropsetReal;
+    lua_rawgetp(L, mtIdx, getPropsetKey());
+    if (lua_istable(L, -1))
+    {
+        int psIdx = lua_absindex(L, -1);
+        for (const auto& k : stPropget)
+        {
+            lua_getfield(L, psIdx, k.c_str());
+            if (lua_isfunction(L, -1))
+            {
+                lua_CFunction fn = lua_tocfunction(L, -1);
+                if (fn != &detail::read_only_error)
+                    stPropsetReal.insert(k);
+            }
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1);
+
+    for (const auto& propName : stPropget)
+    {
+        MemberInfo m;
+        m.name = propName;
+        m.kind = stPropsetReal.count(propName) ? MemberKind::StaticProperty : MemberKind::StaticReadOnlyProperty;
+        m.overloads.push_back(OverloadInfo{});
+        cls.members.push_back(std::move(m));
+    }
+
+    static const std::set<std::string> staticSkipKeys{ "__index", "__newindex", "__metatable" };
+
+    lua_rawgetp(L, mtIdx, getClassKey()); 
+    lua_pop(L, 1);
+
+    lua_pushnil(L);
+    while (lua_next(L, mtIdx))
+    {
+        if (lua_type(L, -2) == LUA_TSTRING)
+        {
+            std::string key = lua_tostring(L, -2);
+            if (!staticSkipKeys.count(key) && !stPropget.count(key))
+            {
+                if (lua_isfunction(L, -1) || lua_isuserdata(L, -1))
+                {
+                    MemberInfo m;
+                    m.name = key;
+                    if (key == "__call")
+                        m.kind = MemberKind::Constructor;
+                    else if (key.size() >= 2 && key[0] == '_' && key[1] == '_')
+                        m.kind = MemberKind::Metamethod;
+                    else
+                        m.kind = MemberKind::StaticMethod;
+                    m.overloads = getOverloadInfos(L, -1);
+                    cls.members.push_back(std::move(m));
+                }
+            }
+        }
+        lua_pop(L, 1);
+    }
+
+    lua_pop(L, 2); 
+    return cls;
+}
+
+inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::string name);
+
+inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::string name)
+{
+    nsIdx = lua_absindex(L, nsIdx);
+    NamespaceInspectInfo info;
+    info.name = std::move(name);
+
+    std::set<std::string> nsPropget;
+    lua_rawgetp(L, nsIdx, getPropgetKey());
+    if (lua_istable(L, -1))
+        nsPropget = collectTableKeys(L, -1);
+    lua_pop(L, 1);
+
+    int nsPropsetTableIdx = 0;
+    lua_rawgetp(L, nsIdx, getPropsetKey());
+    if (lua_istable(L, -1))
+        nsPropsetTableIdx = lua_absindex(L, -1);
+    
+    for (const auto& propName : nsPropget)
+    {
+        MemberInfo m;
+        m.name = propName;
+
+        bool isReadOnly = true;
+        if (nsPropsetTableIdx)
+        {
+            lua_getfield(L, nsPropsetTableIdx, propName.c_str());
+            if (lua_isfunction(L, -1))
+            {
+                lua_CFunction fn = lua_tocfunction(L, -1);
+                isReadOnly = (fn == &detail::read_only_error);
+            }
+            lua_pop(L, 1);
+        }
+
+        m.kind = isReadOnly ? MemberKind::ReadOnlyProperty : MemberKind::Property;
+        m.overloads.push_back(OverloadInfo{});
+        info.freeMembers.push_back(std::move(m));
+    }
+
+    lua_pop(L, 1); 
+
+    static const std::set<std::string> nsSkipKeys{ "__index", "__newindex", "__metatable", "__gc" };
+
+    lua_pushnil(L);
+    while (lua_next(L, nsIdx))
+    {
+        if (lua_type(L, -2) != LUA_TSTRING)
+        {
+            lua_pop(L, 1);
+            continue;
+        }
+
+        std::string key = lua_tostring(L, -2);
+
+        if (nsSkipKeys.count(key) || nsPropget.count(key))
+        {
+            lua_pop(L, 1);
+            continue;
+        }
+
+        if (lua_istable(L, -1))
+        {
+            int valIdx = lua_absindex(L, -1);
+
+            if (isClassStaticTable(L, valIdx))
+            {
+                
+                auto cls = inspectClassFromStaticTable(L, valIdx);
+                
+                info.classes.push_back(std::move(cls));
+            }
+            else
+            {
+                auto sub = inspectNamespaceTable(L, valIdx, key);
+                info.subNamespaces.push_back(std::move(sub));
+            }
+        }
+        else if (lua_isfunction(L, -1))
+        {
+            if (!nsPropget.count(key))
+            {
+                MemberInfo m;
+                m.name = key;
+                m.kind = MemberKind::Method;
+                m.overloads = getOverloadInfos(L, -1);
+                info.freeMembers.push_back(std::move(m));
+            }
+        }
+
+        lua_pop(L, 1); 
+    }
+
+    return info;
+}
+
+} 
+
+template <class T>
+[[nodiscard]] ClassInspectInfo inspect(lua_State* L)
+{
+    
+    lua_rawgetp(L, LUA_REGISTRYINDEX, detail::getClassRegistryKey<T>());
+    if (!lua_istable(L, -1))
+    {
+        lua_pop(L, 1);
+        return {};
+    }
+    
+    lua_rawgetp(L, -1, detail::getStaticKey());
+    if (!lua_istable(L, -1))
+    {
+        lua_pop(L, 2);
+        return {};
+    }
+    
+    lua_rawgetp(L, -1, detail::getClassKey());
+    const bool isClass = lua_istable(L, -1);
+    lua_pop(L, 1);
+
+    if (!isClass)
+    {
+        lua_pop(L, 2);
+        return {};
+    }
+    
+    ClassInspectInfo result = detail::inspectClassFromStaticTable(L, lua_gettop(L));
+    
+    lua_pop(L, 1); 
+    return result;
+}
+
+[[nodiscard]] inline NamespaceInspectInfo inspectNamespace(lua_State* L, const char* namespaceName = nullptr)
+{
+    if (namespaceName == nullptr || namespaceName[0] == '\0')
+    {
+        lua_pushglobaltable(L);
+    }
+    else
+    {
+        
+        std::string path = namespaceName;
+        std::string first;
+        std::string::size_type dot = path.find('.');
+        if (dot == std::string::npos)
+            first = path;
+        else
+            first = path.substr(0, dot);
+
+        lua_getglobal(L, first.c_str());
+        if (!lua_istable(L, -1))
+        {
+            lua_pop(L, 1);
+            return {};
+        }
+
+        while (dot != std::string::npos)
+        {
+            path = path.substr(dot + 1);
+            dot = path.find('.');
+            std::string component = (dot == std::string::npos) ? path : path.substr(0, dot);
+            lua_getfield(L, -1, component.c_str());
+            lua_remove(L, -2); 
+            if (!lua_istable(L, -1))
+            {
+                lua_pop(L, 1);
+                return {};
+            }
+        }
+    }
+
+    std::string label;
+    if (namespaceName && namespaceName[0])
+    {
+        std::string_view sv(namespaceName);
+        auto dot = sv.rfind('.');
+        label = std::string(dot == std::string_view::npos ? sv : sv.substr(dot + 1));
+    }
+    else
+    {
+        label = "_G";
+    }
+    auto result = detail::inspectNamespaceTable(L, -1, label);
+    lua_pop(L, 1);
+    return result;
+}
+
+inline void inspectAccept(lua_State* L, const char* namespaceName, InspectVisitor& visitor)
+{
+    auto ns = inspectNamespace(L, namespaceName);
+    accept(ns, visitor);
+}
+
+class ConsoleVisitor : public InspectVisitor
+{
+public:
+    explicit ConsoleVisitor(std::ostream& out = std::cerr)
+        : out_(out)
+    {
+    }
+
+    void beginNamespace(const NamespaceInspectInfo& ns) override
+    {
+        indent();
+        out_ << "namespace " << ns.name << " {\n";
+        ++depth_;
+    }
+
+    void endNamespace(const NamespaceInspectInfo& 
+) override
+    {
+        --depth_;
+        indent();
+        out_ << "}\n";
+    }
+
+    void visitFreeMember(const NamespaceInspectInfo& 
+, const MemberInfo& m) override
+    {
+        emitMember(m, 
+"");
+    }
+
+    void beginClass(const ClassInspectInfo& cls) override
+    {
+        indent();
+        out_ << "class " << cls.name;
+        if (!cls.baseClasses.empty())
+        {
+            out_ << " extends ";
+            for (std::size_t i = 0; i < cls.baseClasses.size(); ++i)
+            {
+                if (i) out_ << ", ";
+                out_ << cls.baseClasses[i];
+            }
+        }
+        out_ << " {\n";
+        ++depth_;
+    }
+
+    void endClass(const ClassInspectInfo& 
+) override
+    {
+        --depth_;
+        indent();
+        out_ << "}\n";
+    }
+
+    void visitMember(const ClassInspectInfo& cls, const MemberInfo& m) override
+    {
+        emitMember(m, cls.name);
+    }
+
+private:
+    void indent() const
+    {
+        for (int i = 0; i < depth_; ++i)
+            out_ << "    ";
+    }
+
+    static std::string paramStr(const OverloadInfo& ov)
+    {
+        std::string s;
+        for (std::size_t i = 0; i < ov.params.size(); ++i)
+        {
+            if (i) s += ", ";
+            const auto& p = ov.params[i];
+            s += p.hint.empty() ? ("p" + std::to_string(i + 1)) : p.hint;
+            s += ": ";
+            s += p.typeName.empty() ? "any" : p.typeName;
+        }
+        return s;
+    }
+
+    static std::string retStr(const OverloadInfo& ov, const std::string& constructorClass = "")
+    {
+        if (!constructorClass.empty())
+            return constructorClass;
+        return ov.returnType.empty() ? "any" : ov.returnType;
+    }
+
+    void emitMember(const MemberInfo& m, const std::string& className) const
+    {
+        switch (m.kind)
+        {
+        case MemberKind::Property:
+            indent(); out_ << m.name << ": any;\n"; break;
+        case MemberKind::ReadOnlyProperty:
+            indent(); out_ << "readonly " << m.name << ": any;\n"; break;
+        case MemberKind::StaticProperty:
+            indent(); out_ << "static " << m.name << ": any;\n"; break;
+        case MemberKind::StaticReadOnlyProperty:
+            indent(); out_ << "static readonly " << m.name << ": any;\n"; break;
+        case MemberKind::Metamethod:
+            
+            break;
+        case MemberKind::Constructor:
+            for (const auto& ov : m.overloads)
+            {
+                indent();
+                out_ << "constructor(" << paramStr(ov) << ");\n";
+            }
+            break;
+        case MemberKind::Method:
+        case MemberKind::StaticMethod:
+        {
+            bool isStatic = (m.kind == MemberKind::StaticMethod);
+            for (std::size_t i = 0; i < m.overloads.size(); ++i)
+            {
+                indent();
+                if (isStatic) out_ << "static ";
+                out_ << m.name << "(" << paramStr(m.overloads[i]) << "): "
+                     << retStr(m.overloads[i]) << ";\n";
+            }
+            break;
+        }
+        default:
+            break;
+        }
+        (void)className;
+    }
+
+    std::ostream& out_;
+    int depth_ = 0;
+};
+
+class LuaLSVisitor : public InspectVisitor
+{
+public:
+    explicit LuaLSVisitor(std::ostream& out)
+        : out_(out)
+    {
+    }
+
+    void beginNamespace(const NamespaceInspectInfo& ns) override
+    {
+        ns_ = ns.name == "_G" ? "" : ns.name;
+    }
+
+    void endNamespace(const NamespaceInspectInfo& 
+) override {}
+
+    void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) override
+    {
+        if (m.kind != MemberKind::Method && m.kind != MemberKind::StaticMethod)
+            return; 
+
+        for (const auto& ov : m.overloads)
+        {
+            emitParams(ov.params);
+            if (!ov.returnType.empty() && ov.returnType != "void")
+                out_ << "---@return " << luaType(ov.returnType) << "\n";
+        }
+        std::string qual = ns_.empty() ? "" : (ns_ + ".");
+        out_ << "function " << qual << m.name << "(";
+        if (!m.overloads.empty())
+            out_ << paramNames(m.overloads[0].params);
+        out_ << ") end\n\n";
+    }
+
+    void beginClass(const ClassInspectInfo& cls) override
+    {
+        curClass_ = cls.name;
+        out_ << "---@class " << qualifiedName(cls.name);
+        if (!cls.baseClasses.empty())
+        {
+            out_ << " : " << cls.baseClasses[0];
+            for (std::size_t i = 1; i < cls.baseClasses.size(); ++i)
+                out_ << ", " << cls.baseClasses[i];
+        }
+        out_ << "\n";
+
+    }
+
+    void endClass(const ClassInspectInfo& 
+) override
+    {
+        out_ << "local " << curClass_ << " = {}\n\n";
+        curClass_.clear();
+    }
+
+    void visitMember(const ClassInspectInfo& cls, const MemberInfo& m) override
+    {
+        switch (m.kind)
+        {
+        case MemberKind::Property:
+            out_ << "---@field " << m.name << " any\n";
+            break;
+        case MemberKind::ReadOnlyProperty:
+            out_ << "---@field " << m.name << " any # readonly\n";
+            break;
+        case MemberKind::StaticProperty:
+            out_ << "---@field " << m.name << " any\n";
+            break;
+        case MemberKind::StaticReadOnlyProperty:
+            out_ << "---@field " << m.name << " any # readonly\n";
+            break;
+        case MemberKind::Constructor:
+        {
+            out_ << "\n";
+            for (std::size_t i = 0; i < m.overloads.size(); ++i)
+            {
+                const auto& ov = m.overloads[i];
+                if (i == 0)
+                {
+                    emitParams(ov.params);
+                    out_ << "---@return " << cls.name << "\n";
+                    out_ << "function " << cls.name << ".new(" << paramNames(ov.params) << ") end\n";
+                }
+                else
+                {
+                    out_ << "---@overload fun(" << overloadParams(ov.params) << "): " << cls.name << "\n";
+                }
+            }
+            break;
+        }
+        case MemberKind::Method:
+        {
+            out_ << "\n";
+            for (std::size_t i = 0; i < m.overloads.size(); ++i)
+            {
+                const auto& ov = m.overloads[i];
+                if (i == 0)
+                {
+                    emitParams(ov.params, 
+true);
+                    if (!ov.returnType.empty() && ov.returnType != "void")
+                        out_ << "---@return " << luaType(ov.returnType) << "\n";
+                    out_ << "function " << cls.name << ":" << m.name
+                         << "(" << paramNames(ov.params) << ") end\n";
+                }
+                else
+                {
+                    out_ << "---@overload fun(self: " << cls.name << ", " << overloadParams(ov.params) << ")"
+                         << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
+                }
+            }
+            break;
+        }
+        case MemberKind::StaticMethod:
+        {
+            out_ << "\n";
+            for (std::size_t i = 0; i < m.overloads.size(); ++i)
+            {
+                const auto& ov = m.overloads[i];
+                if (i == 0)
+                {
+                    emitParams(ov.params);
+                    if (!ov.returnType.empty() && ov.returnType != "void")
+                        out_ << "---@return " << luaType(ov.returnType) << "\n";
+                    out_ << "function " << cls.name << "." << m.name
+                         << "(" << paramNames(ov.params) << ") end\n";
+                }
+                else
+                {
+                    out_ << "---@overload fun(" << overloadParams(ov.params) << ")"
+                         << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
+                }
+            }
+            break;
+        }
+        default:
+            break;
+        }
+    }
+
+private:
+    
+    static std::string luaType(const std::string& cppType)
+    {
+        if (cppType == "void") return "nil";
+        if (cppType == "bool") return "boolean";
+        if (cppType == "int" || cppType == "long" || cppType == "short" ||
+            cppType == "unsigned int" || cppType == "unsigned long" ||
+            cppType == "unsigned short" || cppType == "int64_t" || cppType == "uint64_t" ||
+            cppType == "int32_t" || cppType == "uint32_t" || cppType == "size_t")
+            return "integer";
+        if (cppType == "float" || cppType == "double") return "number";
+        if (cppType == "std::string" || cppType == "const char *" || cppType == "const char*")
+            return "string";
+        return cppType.empty() ? "any" : cppType;
+    }
+
+    std::string qualifiedName(const std::string& name) const
+    {
+        return ns_.empty() ? name : (ns_ + "." + name);
+    }
+
+    static std::string paramNames(const std::vector<ParamInfo>& params)
+    {
+        std::string s;
+        for (std::size_t i = 0; i < params.size(); ++i)
+        {
+            if (i) s += ", ";
+            s += params[i].hint.empty() ? ("p" + std::to_string(i + 1)) : params[i].hint;
+        }
+        return s;
+    }
+
+    static std::string overloadParams(const std::vector<ParamInfo>& params)
+    {
+        std::string s;
+        for (std::size_t i = 0; i < params.size(); ++i)
+        {
+            if (i) s += ", ";
+            const auto& p = params[i];
+            std::string pname = p.hint.empty() ? ("p" + std::to_string(i + 1)) : p.hint;
+            s += pname + ": " + luaType(p.typeName.empty() ? "any" : p.typeName);
+        }
+        return s;
+    }
+
+    void emitParams(const std::vector<ParamInfo>& params, bool hasSelf = false) const
+    {
+        if (hasSelf)
+            out_ << "---@param self " << curClass_ << "\n";
+        for (std::size_t i = 0; i < params.size(); ++i)
+        {
+            const auto& p = params[i];
+            std::string pname = p.hint.empty() ? ("p" + std::to_string(i + 1)) : p.hint;
+            std::string ptype = p.typeName.empty() ? "any" : luaType(p.typeName);
+            out_ << "---@param " << pname << " " << ptype << "\n";
+        }
+    }
+
+    std::ostream& out_;
+    std::string ns_;
+    std::string curClass_;
+};
+
+class LuaProxyVisitor : public InspectVisitor
+{
+public:
+    explicit LuaProxyVisitor(std::ostream& out)
+        : out_(out)
+    {
+    }
+
+    void beginNamespace(const NamespaceInspectInfo& ns) override
+    {
+        if (ns.name != "_G")
+            out_ << "local " << ns.name << " = {}\n\n";
+    }
+
+    void endNamespace(const NamespaceInspectInfo& ns) override
+    {
+        if (ns.name != "_G")
+            out_ << "return " << ns.name << "\n";
+    }
+
+    void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) override
+    {
+        if (m.kind != MemberKind::Method && m.kind != MemberKind::StaticMethod)
+            return;
+        std::string qual = (ns.name == "_G") ? "" : (ns.name + ".");
+        if (!m.overloads.empty())
+        {
+            out_ << "function " << qual << m.name
+                 << "(" << paramNames(m.overloads[0].params) << ") end\n";
+        }
+    }
+
+    void beginClass(const ClassInspectInfo& cls) override
+    {
+        curClass_ = cls.name;
+        out_ << cls.name << " = {}\n";
+        out_ << cls.name << ".__index = " << cls.name << "\n\n";
+    }
+
+    void endClass(const ClassInspectInfo& 
+) override
+    {
+        curClass_.clear();
+        out_ << "\n";
+    }
+
+    void visitMember(const ClassInspectInfo& 
+, const MemberInfo& m) override
+    {
+        if (m.overloads.empty())
+            return;
+
+        switch (m.kind)
+        {
+        case MemberKind::Constructor:
+            out_ << "function " << curClass_ << ".new("
+                 << paramNames(m.overloads[0].params) << ")\n"
+                 << "    return setmetatable({}, " << curClass_ << ")\n"
+                 << "end\n\n";
+            break;
+        case MemberKind::Method:
+            out_ << "function " << curClass_ << ":" << m.name
+                 << "(" << paramNames(m.overloads[0].params) << ") end\n";
+            break;
+        case MemberKind::StaticMethod:
+            out_ << "function " << curClass_ << "." << m.name
+                 << "(" << paramNames(m.overloads[0].params) << ") end\n";
+            break;
+        case MemberKind::Property:
+        case MemberKind::ReadOnlyProperty:
+        case MemberKind::StaticProperty:
+        case MemberKind::StaticReadOnlyProperty:
+            
+            break;
+        default:
+            break;
+        }
+    }
+
+private:
+    static std::string paramNames(const std::vector<ParamInfo>& params)
+    {
+        std::string s;
+        for (std::size_t i = 0; i < params.size(); ++i)
+        {
+            if (i) s += ", ";
+            s += params[i].hint.empty() ? ("p" + std::to_string(i + 1)) : params[i].hint;
+        }
+        return s;
+    }
+
+    std::ostream& out_;
+    std::string curClass_;
+};
+
+class JsonVisitor : public InspectVisitor
+{
+public:
+    explicit JsonVisitor(std::ostream& out)
+        : out_(out)
+    {
+    }
+
+    void beginNamespace(const NamespaceInspectInfo& ns) override
+    {
+        if (depth_ == 0) out_ << "{\n";
+        indent(); out_ << "\"name\": \"" << escape(ns.name) << "\",\n";
+        indent(); out_ << "\"freeMembers\": [],\n";
+        indent(); out_ << "\"classes\": [\n";
+        ++depth_;
+        firstClass_ = true;
+    }
+
+    void endNamespace(const NamespaceInspectInfo& 
+) override
+    {
+        --depth_;
+        out_ << "\n";
+        indent(); out_ << "]\n";
+        if (depth_ == 0) out_ << "}\n";
+    }
+
+    void beginClass(const ClassInspectInfo& cls) override
+    {
+        if (!firstClass_) out_ << ",\n";
+        firstClass_ = false;
+        indent(); out_ << "{\n";
+        ++depth_;
+        indent(); out_ << "\"name\": \"" << escape(cls.name) << "\",\n";
+        indent(); out_ << "\"bases\": [";
+        for (std::size_t i = 0; i < cls.baseClasses.size(); ++i)
+        {
+            if (i) out_ << ", ";
+            out_ << "\"" << escape(cls.baseClasses[i]) << "\"";
+        }
+        out_ << "],\n";
+        indent(); out_ << "\"members\": [\n";
+        ++depth_;
+        firstMember_ = true;
+    }
+
+    void endClass(const ClassInspectInfo& 
+) override
+    {
+        --depth_;
+        out_ << "\n";
+        indent(); out_ << "]\n";
+        --depth_;
+        indent(); out_ << "}";
+    }
+
+    void visitMember(const ClassInspectInfo& 
+, const MemberInfo& m) override
+    {
+        if (!firstMember_) out_ << ",\n";
+        firstMember_ = false;
+        indent();
+        out_ << "{ \"name\": \"" << escape(m.name) << "\""
+             << ", \"kind\": \"" << kindStr(m.kind) << "\""
+             << ", \"overloads\": " << m.overloads.size()
+             << " }";
+    }
+
+private:
+    void indent() const
+    {
+        for (int i = 0; i < depth_; ++i)
+            out_ << "  ";
+    }
+
+    static std::string escape(const std::string& s)
+    {
+        std::string out;
+        for (char c : s)
+        {
+            if (c == '"') out += "\\\"";
+            else if (c == '\\') out += "\\\\";
+            else out += c;
+        }
+        return out;
+    }
+
+    static const char* kindStr(MemberKind k)
+    {
+        switch (k)
+        {
+        case MemberKind::Method: return "method";
+        case MemberKind::StaticMethod: return "static_method";
+        case MemberKind::Property: return "property";
+        case MemberKind::ReadOnlyProperty: return "readonly_property";
+        case MemberKind::StaticProperty: return "static_property";
+        case MemberKind::StaticReadOnlyProperty: return "static_readonly_property";
+        case MemberKind::Constructor: return "constructor";
+        case MemberKind::Metamethod: return "metamethod";
+        default: return "unknown";
+        }
+    }
+
+    std::ostream& out_;
+    int depth_ = 0;
+    bool firstClass_ = true;
+    bool firstMember_ = true;
+};
+
+class LuaTableVisitor : public InspectVisitor
+{
+public:
+    explicit LuaTableVisitor(lua_State* L)
+        : L_(L)
+    {
+    }
+
+    void beginNamespace(const NamespaceInspectInfo& ns) override
+    {
+        lua_newtable(L_); 
+        lua_pushstring(L_, ns.name.c_str());
+        lua_setfield(L_, -2, "name");
+
+        lua_newtable(L_);
+        lua_setfield(L_, -2, "freeMembers");
+        freeMemberIdx_ = 1;
+
+        lua_newtable(L_);
+        lua_setfield(L_, -2, "classes");
+        classIdx_ = 1;
+
+        lua_newtable(L_);
+        lua_setfield(L_, -2, "subNamespaces");
+        subNsIdx_ = 1;
+    }
+
+    void endNamespace(const NamespaceInspectInfo& 
+) override
+    {
+        
+    }
+
+    void visitFreeMember(const NamespaceInspectInfo& 
+, const MemberInfo& m) override
+    {
+        lua_getfield(L_, -1, "freeMembers");
+        pushMemberInfo(m);
+        lua_rawseti(L_, -2, freeMemberIdx_++);
+        lua_pop(L_, 1);
+    }
+
+    void beginClass(const ClassInspectInfo& cls) override
+    {
+        lua_newtable(L_);
+        lua_pushstring(L_, cls.name.c_str());
+        lua_setfield(L_, -2, "name");
+
+        lua_newtable(L_);
+        for (std::size_t i = 0; i < cls.baseClasses.size(); ++i)
+        {
+            lua_pushstring(L_, cls.baseClasses[i].c_str());
+            lua_rawseti(L_, -2, static_cast<int>(i + 1));
+        }
+        lua_setfield(L_, -2, "bases");
+
+        lua_newtable(L_);
+        lua_setfield(L_, -2, "members");
+        memberIdx_ = 1;
+    }
+
+    void endClass(const ClassInspectInfo& 
+) override
+    {
+        
+        lua_getfield(L_, -2, "classes");
+        lua_pushvalue(L_, -2);
+        lua_rawseti(L_, -2, classIdx_++);
+        lua_pop(L_, 2); 
+    }
+
+    void visitMember(const ClassInspectInfo& 
+, const MemberInfo& m) override
+    {
+        lua_getfield(L_, -1, "members");
+        pushMemberInfo(m);
+        lua_rawseti(L_, -2, memberIdx_++);
+        lua_pop(L_, 1);
+    }
+
+private:
+    void pushMemberInfo(const MemberInfo& m)
+    {
+        lua_newtable(L_);
+        lua_pushstring(L_, m.name.c_str());
+        lua_setfield(L_, -2, "name");
+        lua_pushstring(L_, kindStr(m.kind));
+        lua_setfield(L_, -2, "kind");
+        lua_pushinteger(L_, static_cast<lua_Integer>(m.overloads.size()));
+        lua_setfield(L_, -2, "overloads");
+
+        lua_newtable(L_);
+        for (std::size_t i = 0; i < m.overloads.size(); ++i)
+        {
+            const auto& ov = m.overloads[i];
+            lua_newtable(L_);
+            lua_pushstring(L_, ov.returnType.c_str());
+            lua_setfield(L_, -2, "returnType");
+
+            lua_newtable(L_);
+            for (std::size_t j = 0; j < ov.params.size(); ++j)
+            {
+                lua_newtable(L_);
+                lua_pushstring(L_, ov.params[j].typeName.c_str());
+                lua_setfield(L_, -2, "type");
+                lua_pushstring(L_, ov.params[j].hint.c_str());
+                lua_setfield(L_, -2, "hint");
+                lua_rawseti(L_, -2, static_cast<int>(j + 1));
+            }
+            lua_setfield(L_, -2, "params");
+            lua_rawseti(L_, -2, static_cast<int>(i + 1));
+        }
+        lua_setfield(L_, -2, "overloadDetails");
+    }
+
+    static const char* kindStr(MemberKind k)
+    {
+        switch (k)
+        {
+        case MemberKind::Method: return "method";
+        case MemberKind::StaticMethod: return "static_method";
+        case MemberKind::Property: return "property";
+        case MemberKind::ReadOnlyProperty: return "readonly_property";
+        case MemberKind::StaticProperty: return "static_property";
+        case MemberKind::StaticReadOnlyProperty: return "static_readonly_property";
+        case MemberKind::Constructor: return "constructor";
+        case MemberKind::Metamethod: return "metamethod";
+        default: return "unknown";
+        }
+    }
+
+    lua_State* L_;
+    int freeMemberIdx_ = 1;
+    int classIdx_ = 1;
+    int subNsIdx_ = 1;
+    int memberIdx_ = 1;
+};
+
+inline void inspectPrint(lua_State* L, const char* namespaceName = nullptr, std::ostream& stream = std::cerr)
+{
+    auto ns = inspectNamespace(L, namespaceName);
+    ConsoleVisitor v(stream);
+    accept(ns, v);
+}
+
+inline void inspectToLua(lua_State* L, const char* namespaceName = nullptr)
+{
+    auto ns = inspectNamespace(L, namespaceName);
+    LuaTableVisitor v(L);
+    accept(ns, v);
+}
+
+} 
+
+
+// End File: Source/LuaBridge/Inspect.h
+
+// Begin File: Source/LuaBridge/List.h
+
+namespace luabridge {
+
+template <class T>
+struct Stack<std::list<T>>
+{
+    using Type = std::list<T>;
+    
+    [[nodiscard]] static Result push(lua_State* L, const Type& list)
+    {
+#if LUABRIDGE_SAFE_STACK_CHECKS
+        if (! lua_checkstack(L, 3))
+            return makeErrorCode(ErrorCode::LuaStackOverflow);
+#endif
+
+        StackRestore stackRestore(L);
+
+        lua_createtable(L, static_cast<int>(list.size()), 0);
+
+        auto it = list.cbegin();
+        for (lua_Integer tableIndex = 1; it != list.cend(); ++tableIndex, ++it)
+        {
+            lua_pushinteger(L, tableIndex);
+
+            auto result = Stack<T>::push(L, *it);
+            if (! result)
+                return result;
+
+            lua_settable(L, -3);
+        }
+
+        stackRestore.reset();
+        return {};
+    }
+
+    [[nodiscard]] static TypeResult<Type> get(lua_State* L, int index)
+    {
+        if (!lua_istable(L, index))
+            return makeErrorCode(ErrorCode::InvalidTypeCast);
+
+        const StackRestore stackRestore(L);
+
+        Type list;
+
+        int absIndex = lua_absindex(L, index);
+        lua_pushnil(L);
+
+        while (lua_next(L, absIndex) != 0)
+        {
+            auto item = Stack<T>::get(L, -1);
+            if (! item)
+                return makeErrorCode(ErrorCode::InvalidTypeCast);
+
+            list.emplace_back(*item);
+            lua_pop(L, 1);
+        }
+
+        return list;
+    }
+
+    [[nodiscard]] static bool isInstance(lua_State* L, int index)
+    {
+        return lua_istable(L, index);
+    }
+};
+
+} 
+
+
+// End File: Source/LuaBridge/List.h
+
+// Begin File: Source/LuaBridge/detail/Coroutine.h
+
+#if LUABRIDGE_HAS_CXX20_COROUTINES
+
+#if LUABRIDGE_ON_LUAJIT || LUA_VERSION_NUM == 501 || LUABRIDGE_ON_LUAU
+#ifndef LUABRIDGE_DISABLE_COROUTINE_INTEGRATION
+#error "C++20 coroutine integration requires Lua 5.2+ with lua_yieldk support. \
+Define LUABRIDGE_DISABLE_COROUTINE_INTEGRATION to suppress this error."
+#endif
+#else
+
+namespace luabridge {
+
+template <class R>
+struct CppCoroutine
+{
+    struct promise_type
+    {
+        lua_State* L = nullptr;
+        int nresults = 0;
+        bool is_done = false;
+        std::exception_ptr exception;
+
+        std::suspend_always initial_suspend() noexcept { return {}; }
+        std::suspend_always final_suspend() noexcept { return {}; }
+
+        void unhandled_exception() noexcept
+        {
+            exception = std::current_exception();
+        }
+
+        std::suspend_always yield_value(const R& value)
+        {
+            nresults = 0;
+            if (L)
+            {
+                auto result = Stack<R>::push(L, value);
+                if (result)
+                    nresults = 1;
+                else
+                    exception = std::make_exception_ptr(std::system_error(result.error()));
+            }
+            return {};
+        }
+
+        std::suspend_always yield_value(R&& value)
+        {
+            nresults = 0;
+            if (L)
+            {
+                auto result = Stack<R>::push(L, std::move(value));
+                if (result)
+                    nresults = 1;
+                else
+                    exception = std::make_exception_ptr(std::system_error(result.error()));
+            }
+            return {};
+        }
+
+        void return_value(const R& value)
+        {
+            nresults = 0;
+            if (L)
+            {
+                auto result = Stack<R>::push(L, value);
+                if (result)
+                    nresults = 1;
+                else
+                    exception = std::make_exception_ptr(std::system_error(result.error()));
+            }
+            is_done = true;
+        }
+
+        void return_value(R&& value)
+        {
+            nresults = 0;
+            if (L)
+            {
+                auto result = Stack<R>::push(L, std::move(value));
+                if (result)
+                    nresults = 1;
+                else
+                    exception = std::make_exception_ptr(std::system_error(result.error()));
+            }
+            is_done = true;
+        }
+
+        CppCoroutine get_return_object()
+        {
+            return CppCoroutine{ std::coroutine_handle<promise_type>::from_promise(*this) };
+        }
+    };
+
+    std::coroutine_handle<promise_type> handle;
+
+    explicit CppCoroutine(std::coroutine_handle<promise_type> h) noexcept
+        : handle(h)
+    {
+    }
+
+    CppCoroutine(CppCoroutine&& other) noexcept
+        : handle(std::exchange(other.handle, {}))
+    {
+    }
+
+    CppCoroutine(const CppCoroutine&) = delete;
+    CppCoroutine& operator=(const CppCoroutine&) = delete;
+    ~CppCoroutine() = default;
+};
+
+template <>
+struct CppCoroutine<void>
+{
+    struct promise_type
+    {
+        lua_State* L = nullptr;
+        int nresults = 0;
+        bool is_done = false;
+        std::exception_ptr exception;
+
+        std::suspend_always initial_suspend() noexcept { return {}; }
+        std::suspend_always final_suspend() noexcept { return {}; }
+
+        void unhandled_exception() noexcept
+        {
+            exception = std::current_exception();
+        }
+
+        void return_void()
+        {
+            nresults = 0;
+            is_done = true;
+        }
+
+        CppCoroutine get_return_object()
+        {
+            return CppCoroutine{ std::coroutine_handle<promise_type>::from_promise(*this) };
+        }
+    };
+
+    std::coroutine_handle<promise_type> handle;
+
+    explicit CppCoroutine(std::coroutine_handle<promise_type> h) noexcept
+        : handle(h)
+    {
+    }
+
+    CppCoroutine(CppCoroutine&& other) noexcept
+        : handle(std::exchange(other.handle, {}))
+    {
+    }
+
+    CppCoroutine(const CppCoroutine&) = delete;
+    CppCoroutine& operator=(const CppCoroutine&) = delete;
+    ~CppCoroutine() = default;
+};
+
+class LuaCoroutine
+{
+public:
+    LuaCoroutine(lua_State* thread, lua_State* from = nullptr) noexcept
+        : m_thread(thread)
+        , m_from(from)
+    {
+    }
+
+    bool await_ready() noexcept
+    {
+        m_status = lua_resume_x(m_thread, m_from, 0, &m_nresults);
+        return true; 
+    }
+
+    void await_suspend(std::coroutine_handle<>) noexcept
+    {
+        
+    }
+
+    std::pair<int, int> await_resume() noexcept
+    {
+        return { m_status, m_nresults };
+    }
+
+private:
+    lua_State* m_thread;
+    lua_State* m_from;
+    int m_status = LUABRIDGE_LUA_OK;
+    int m_nresults = 0;
+};
+
+namespace detail {
+
+template <class T>
+struct is_cpp_coroutine : std::false_type
+{
+};
+
+template <class R>
+struct is_cpp_coroutine<CppCoroutine<R>> : std::true_type
+{
+};
+
+template <class F, class = void>
+struct is_cpp_coroutine_factory : std::false_type
+{
+};
+
+template <class F>
+struct is_cpp_coroutine_factory<F, std::void_t<typename function_traits<std::remove_reference_t<F>>::result_type>>
+    : is_cpp_coroutine<typename function_traits<std::remove_reference_t<F>>::result_type>
+{
+};
+
+template <class F>
+inline constexpr bool is_cpp_coroutine_factory_v = is_cpp_coroutine_factory<F>::value;
+
+template <class CoroType>
+struct CppCoroutineFrame
+{
+    using HandleType = std::coroutine_handle<typename CoroType::promise_type>;
+
+    HandleType handle;
+
+    explicit CppCoroutineFrame(HandleType h) noexcept
+        : handle(h)
+    {
+    }
+
+    CppCoroutineFrame(const CppCoroutineFrame&) = delete;
+    CppCoroutineFrame& operator=(const CppCoroutineFrame&) = delete;
+
+    ~CppCoroutineFrame()
+    {
+        if (handle && !handle.done())
+            handle.destroy();
+    }
+};
+
+template <class F> int coroutine_continuation_body(lua_State* L, int frame_abs_idx);
+
+#if LUA_VERSION_NUM < 503
+
+template <class F>
+int coroutine_continuation(lua_State* L)
+{
+    int frame_abs_idx = 0;
+    lua_getctx(L, &frame_abs_idx);
+    return coroutine_continuation_body<F>(L, frame_abs_idx);
+}
+
+template <class F>
+int do_yield(lua_State* L, int nresults, int frame_abs_idx)
+{
+    return lua_yieldk(L, nresults, frame_abs_idx, &coroutine_continuation<F>);
+}
+#else
+
+template <class F>
+int coroutine_continuation(lua_State* L, int 
+, lua_KContext ctx)
+{
+    return coroutine_continuation_body<F>(L, static_cast<int>(ctx));
+}
+
+template <class F>
+int do_yield(lua_State* L, int nresults, int frame_abs_idx)
+{
+    return lua_yieldk(L, nresults, static_cast<lua_KContext>(frame_abs_idx), &coroutine_continuation<F>);
+}
+#endif
+
+[[noreturn]] inline void raise_from_exception(lua_State* L, int frame_abs_idx, std::exception_ptr ex)
+{
+    lua_settop(L, frame_abs_idx - 1); 
+
+#if LUABRIDGE_HAS_EXCEPTIONS
+    try
+    {
+        std::rethrow_exception(ex);
+    }
+    catch (const std::exception& e)
+    {
+        raise_lua_error(L, "%s", e.what());
+    }
+    catch (...)
+    {
+#endif
+
+        raise_lua_error(L, "unknown exception in C++ coroutine");
+
+#if LUABRIDGE_HAS_EXCEPTIONS
+    }
+#endif
+}
+
+template <class F>
+int coroutine_continuation_body(lua_State* L, int frame_abs_idx)
+{
+    using CoroType = typename function_traits<std::remove_reference_t<F>>::result_type;
+    using FrameType = CppCoroutineFrame<CoroType>;
+
+    lua_settop(L, frame_abs_idx);
+
+    auto* frame = align<FrameType>(lua_touserdata(L, frame_abs_idx));
+
+    frame->handle.resume();
+
+    auto& promise = frame->handle.promise();
+
+    if (promise.exception)
+        raise_from_exception(L, frame_abs_idx, promise.exception);
+
+    if (promise.is_done)
+    {
+        if (promise.nresults == 1)
+            lua_replace(L, frame_abs_idx); 
+        else
+            lua_settop(L, frame_abs_idx - 1); 
+        return promise.nresults;
+    }
+
+    return do_yield<F>(L, promise.nresults, frame_abs_idx);
+}
+
+template <class F>
+int invoke_coroutine_entry(lua_State* L)
+{
+    using FnTraits = function_traits<std::remove_reference_t<F>>;
+    using ArgsPack = typename FnTraits::argument_types;
+    using CoroType = typename FnTraits::result_type;
+    using FrameType = CppCoroutineFrame<CoroType>;
+
+    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
+    auto& factory = *align<F>(lua_touserdata(L, lua_upvalueindex(1)));
+
+    auto coro = invoke_callable_from_stack<ArgsPack, 1>(L, factory);
+
+    lua_newuserdata_aligned<FrameType>(L, std::move(coro.handle));
+    coro.handle = {}; 
+
+    int frame_abs_idx = lua_gettop(L);
+    auto* frame = align<FrameType>(lua_touserdata(L, frame_abs_idx));
+
+    frame->handle.promise().L = L;
+
+    frame->handle.resume();
+
+    auto& promise = frame->handle.promise();
+
+    if (promise.exception)
+        raise_from_exception(L, frame_abs_idx, promise.exception);
+
+    if (promise.is_done)
+    {
+        if (promise.nresults == 1)
+            lua_replace(L, frame_abs_idx); 
+        else
+            lua_settop(L, frame_abs_idx - 1); 
+        return promise.nresults;
+    }
+
+    return do_yield<F>(L, promise.nresults, frame_abs_idx);
+}
+
+template <class F, class = std::enable_if_t<is_cpp_coroutine_factory_v<F>>>
+inline void push_coroutine_function(lua_State* L, F&& f, const char* debugname)
+{
+    using FDecay = std::decay_t<F>;
+    lua_newuserdata_aligned<FDecay>(L, std::forward<F>(f));
+    lua_pushcclosure_x(L, &invoke_coroutine_entry<FDecay>, debugname, 1);
+}
+
+} 
+} 
+
+#endif 
+#endif 
+
+
+// End File: Source/LuaBridge/detail/Coroutine.h
+
+// Begin File: Source/LuaBridge/detail/Enum.h
+
+namespace luabridge {
+
+template <class T, T... Values>
+struct Enum
+{
+    static_assert(std::is_enum_v<T>);
+
+    using Type = std::underlying_type_t<T>;
+
+    [[nodiscard]] static Result push(lua_State* L, T value)
+    {
+        return Stack<Type>::push(L, static_cast<Type>(value));
+    }
+
+    [[nodiscard]] static TypeResult<T> get(lua_State* L, int index)
+    {
+        const auto result = Stack<Type>::get(L, index);
+        if (! result)
+            return result.error();
+
+        if constexpr (sizeof...(Values) > 0)
+        {
+            constexpr Type values[] = { static_cast<Type>(Values)... };
+            for (std::size_t i = 0; i < sizeof...(Values); ++i)
+            {
+                if (values[i] == *result)
+                    return static_cast<T>(*result);
+            }
+
+            return makeErrorCode(ErrorCode::InvalidTypeCast);
+        }
+        else
+        {
+            return static_cast<T>(*result);
+        }
+    }
+
+    [[nodiscard]] static bool isInstance(lua_State* L, int index)
+    {
+        return lua_type(L, index) == LUA_TNUMBER;
+    }
+};
+
+} 
+
+
+// End File: Source/LuaBridge/detail/Enum.h
+
+// Begin File: Source/LuaBridge/detail/FunctionHints.h
+
+namespace luabridge {
+
+template <class F>
+struct FunctionWithHints
+{
+    using func_type = F;
+
+    F func;
+    std::vector<std::string> hints; 
+};
+
+template <class F, class... Names>
+[[nodiscard]] auto withHints(F&& func, Names&&... paramNames) -> FunctionWithHints<std::decay_t<F>>
+{
+    return { std::forward<F>(func), { std::string(std::forward<Names>(paramNames))... } };
+}
+
+namespace detail {
+
+template <class T>
+struct unwrap_fn_type
+{
+    using type = T;
+};
+
+template <class F>
+struct unwrap_fn_type<FunctionWithHints<F>>
+{
+    using type = F;
+};
+
+template <class T>
+using unwrap_fn_type_t = typename unwrap_fn_type<T>::type;
+
+template <class T>
+struct is_function_with_hints : std::false_type
+{
+};
+
+template <class F>
+struct is_function_with_hints<FunctionWithHints<F>> : std::true_type
+{
+};
+
+template <class T>
+inline static constexpr bool is_function_with_hints_v = is_function_with_hints<T>::value;
+
+template <class F>
+struct function_traits<FunctionWithHints<F>> : function_traits<F>
+{
+};
+
+template <class F>
+struct is_callable<FunctionWithHints<F>>
+{
+    static constexpr bool value = is_callable_v<F>;
+};
+
+template <class F>
+struct is_const_member_function_pointer<FunctionWithHints<F>>
+{
+    static constexpr bool value = is_const_member_function_pointer_v<F>;
+};
+
+template <class F>
+[[nodiscard]] decltype(auto) get_underlying(F&& f) noexcept
+{
+    return std::forward<F>(f);
+}
+
+template <class F>
+[[nodiscard]] F&& get_underlying(FunctionWithHints<F>&& f) noexcept
+{
+    return std::move(f.func);
+}
+
+template <class F>
+[[nodiscard]] F& get_underlying(FunctionWithHints<F>& f) noexcept
+{
+    return f.func;
+}
+
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+
+template <class Tuple>
+[[nodiscard]] std::vector<std::string> reflect_param_type_names()
+{
+    std::vector<std::string> result;
+
+    [&]<std::size_t... I>(std::index_sequence<I...>)
+    {
+        (
+            [&]
+            {
+                using ParamT = std::tuple_element_t<I, Tuple>;
+
+                constexpr bool isLuaState =
+                    std::is_pointer_v<ParamT> &&
+                    std::is_same_v<std::remove_const_t<std::remove_pointer_t<ParamT>>, lua_State>;
+
+                if constexpr (!isLuaState)
+                    result.push_back(std::string(typeName<std::remove_cvref_t<ParamT>>()));
+            }(),
+            ...);
+    }(std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+
+    return result;
+}
+
+#endif 
+
+} 
+} 
+
+
+// End File: Source/LuaBridge/detail/FunctionHints.h
+
+// Begin File: Source/LuaBridge/detail/Globals.h
+
+namespace luabridge {
+
+template <class T>
+TypeResult<T> getGlobal(lua_State* L, const char* name)
+{
+    lua_getglobal(L, name);
+
+    auto result = luabridge::Stack<T>::get(L, -1);
+
+    lua_pop(L, 1);
+
+    return result;
+}
+
+template <class T>
+bool setGlobal(lua_State* L, T&& t, const char* name)
+{
+    if (auto result = push(L, std::forward<T>(t)))
+    {
+        lua_setglobal(L, name);
+        return true;
+    }
+
+    return false;
+}
+
+} 
+
+
+// End File: Source/LuaBridge/detail/Globals.h
+
+// Begin File: Source/LuaBridge/detail/LuaRef.h
+
+namespace luabridge {
+
+template <class Signature>
+class LuaFunction;
+
+struct LuaNil
+{
+};
+
+template <>
+struct Stack<LuaNil>
+{
+    [[nodiscard]] static Result push(lua_State* L, const LuaNil&)
+    {
+#if LUABRIDGE_SAFE_STACK_CHECKS
+        if (! lua_checkstack(L, 1))
+            return makeErrorCode(ErrorCode::LuaStackOverflow);
+#endif
+
+        lua_pushnil(L);
+        return {};
+    }
+
+    [[nodiscard]] static bool isInstance(lua_State* L, int index)
+    {
+        return lua_type(L, index) == LUA_TNIL;
+    }
+};
+
+template <class Impl, class LuaRef>
+class LuaRefBase
+{
+protected:
+    friend struct Stack<LuaRef>;
+
+    struct FromStack
+    {
+    };
+
+    LuaRefBase(lua_State* L) noexcept
+        : m_L(L)
+    {
+        LUABRIDGE_ASSERT(L != nullptr);
+    }
+
+    int createRef() const
     {
         impl().push(m_L);
 
@@ -11014,11 +12853,44 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                
+                ([&]
+                {
+                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                    detail::OverloadEntry entry;
+                    if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
+                    {
+                        using ArgsPack = detail::function_arguments_t<Functions>;
+                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
+                        entry.checker = &detail::overload_type_checker<ArgsPack>;
+                        entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                        entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        if constexpr (detail::is_function_with_hints_v<Functions>)
+                            entry.paramHints = functions.hints;
+                    }
+                    else
+                    {
+                        entry.arity = -1;
+                        entry.checker = nullptr;
+                    }
+                    overload_set->entries.push_back(std::move(entry));
+
+                    lua_createtable(L, 1, 0);
+                    detail::push_function(L, detail::get_underlying(std::move(functions)), name);
+                    lua_rawseti(L, -2, 1);
+                    lua_pushcclosure_x(L, &detail::try_overload_functions<false>, name, 2);
+
+                } (), ...);
+#else
                 ([&]
                 {
-                    detail::push_function(L, std::move(functions), name);
+                    detail::push_function(L, detail::get_underlying(std::move(functions)), name);
 
                 } (), ...);
+#endif
             }
             else
             {
@@ -11039,6 +12911,12 @@ class Namespace : public detail::Registrar
                         using ArgsPack = detail::function_arguments_t<Functions>;
                         entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                         entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                        entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                        entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        if constexpr (detail::is_function_with_hints_v<Functions>)
+                            entry.paramHints = functions.hints;
+#endif
                     }
                     overload_set->entries.push_back(entry);
 
@@ -11050,7 +12928,7 @@ class Namespace : public detail::Registrar
 
                 ([&]
                 {
-                    detail::push_function(L, std::move(functions), name);
+                    detail::push_function(L, detail::get_underlying(std::move(functions)), name);
                     lua_rawseti(L, -2, idx++);
 
                 } (), ...);
@@ -11177,11 +13055,55 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                
+                ([&]
+                {
+                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                    detail::OverloadEntry entry;
+                    if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
+                    {
+                        if constexpr (detail::is_proxy_member_function_v<T, Functions>)
+                        {
+                            using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
+                            entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
+                            entry.checker = &detail::overload_type_checker<ArgsPack>;
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        }
+                        else
+                        {
+                            using ArgsPack = detail::function_arguments_t<Functions>;
+                            entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
+                            entry.checker = &detail::overload_type_checker<ArgsPack>;
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        }
+                        if constexpr (detail::is_function_with_hints_v<Functions>)
+                            entry.paramHints = functions.hints;
+                    }
+                    else
+                    {
+                        entry.arity = -1;
+                        entry.checker = nullptr;
+                    }
+                    overload_set->entries.push_back(std::move(entry));
+
+                    lua_createtable(L, 1, 0);
+                    detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
+                    lua_rawseti(L, -2, 1);
+                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, name, 2);
+
+                } (), ...);
+#else
                 ([&]
                 {
-                    detail::push_member_function<T>(L, std::move(functions), name);
+                    detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
 
                 } (), ...);
+#endif
 
                 if constexpr (detail::const_functions_count<T, Functions...> == 1)
                 {
@@ -11219,12 +13141,24 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                            if constexpr (detail::is_function_with_hints_v<Functions>)
+                                entry.paramHints = functions.hints;
+#endif
                         }
                         else
                         {
                             using ArgsPack = detail::function_arguments_t<Functions>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                            if constexpr (detail::is_function_with_hints_v<Functions>)
+                                entry.paramHints = functions.hints;
+#endif
                         }
                         overload_set_const->entries.push_back(entry);
 
@@ -11241,7 +13175,7 @@ class Namespace : public detail::Registrar
                         if (!detail::is_const_function<T, Functions>)
                             return;
 
-                        detail::push_member_function<T>(L, std::move(functions), name);
+                        detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
                         lua_rawseti(L, -2, idx++);
 
                     } (), ...);
@@ -11274,12 +13208,24 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                            if constexpr (detail::is_function_with_hints_v<Functions>)
+                                entry.paramHints = functions.hints;
+#endif
                         }
                         else
                         {
                             using ArgsPack = detail::function_arguments_t<Functions>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                            if constexpr (detail::is_function_with_hints_v<Functions>)
+                                entry.paramHints = functions.hints;
+#endif
                         }
                         overload_set_nonconst->entries.push_back(entry);
 
@@ -11296,7 +13242,7 @@ class Namespace : public detail::Registrar
                         if (detail::is_const_function<T, Functions>)
                             return;
 
-                        detail::push_member_function<T>(L, std::move(functions), name);
+                        detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
                         lua_rawseti(L, -2, idx++);
 
                     } (), ...);
@@ -11309,6 +13255,47 @@ class Namespace : public detail::Registrar
             return *this;
         }
 
+#if LUABRIDGE_HAS_CXX20_COROUTINES
+        
+        template <class F>
+        auto addStaticCoroutine(const char* name, F factory)
+            -> std::enable_if_t<detail::is_cpp_coroutine_factory_v<F>, Class<T>&>
+        {
+            LUABRIDGE_ASSERT(name != nullptr);
+            assertStackState(); 
+
+            detail::push_coroutine_function(L, std::move(factory), name);
+            rawsetfield(L, -2, name); 
+
+            return *this;
+        }
+
+        template <class F>
+        auto addCoroutine(const char* name, F factory)
+            -> std::enable_if_t<
+                detail::is_cpp_coroutine_factory_v<F> && detail::is_proxy_member_function_v<T, F>,
+                Class<T>&>
+        {
+            LUABRIDGE_ASSERT(name != nullptr);
+            assertStackState(); 
+
+            detail::push_coroutine_function(L, std::move(factory), name);
+
+            if constexpr (detail::is_const_function<T, F>)
+            {
+                lua_pushvalue(L, -1); 
+                rawsetfield(L, -4, name); 
+                rawsetfield(L, -4, name); 
+            }
+            else
+            {
+                rawsetfield(L, -3, name); 
+            }
+
+            return *this;
+        }
+#endif 
+
         template <class... Functions>
         auto addConstructor()
             -> std::enable_if_t<(sizeof...(Functions) > 0), Class<T>&>
@@ -11317,11 +13304,35 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                
+                ([&]
+                {
+                    using ArgsPack = detail::function_arguments_t<Functions>;
+
+                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                    detail::OverloadEntry entry;
+                    entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
+                    entry.checker = &detail::overload_type_checker<ArgsPack>;
+                    entry.returnType = std::string(detail::typeName<T>());
+                    entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                    overload_set->entries.push_back(std::move(entry));
+
+                    lua_createtable(L, 1, 0);
+                    lua_pushcclosure_x(L, &detail::constructor_placement_proxy<T, ArgsPack>, className, 0);
+                    lua_rawseti(L, -2, 1);
+                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, className, 2);
+
+                } (), ...);
+#else
                 ([&]
                 {
                     lua_pushcclosure_x(L, &detail::constructor_placement_proxy<T, detail::function_arguments_t<Functions>>, className, 0);
 
                 } (), ...);
+#endif
             }
             else
             {
@@ -11335,6 +13346,10 @@ class Namespace : public detail::Registrar
                     detail::OverloadEntry entry;
                     entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                     entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                    entry.returnType = std::string(detail::typeName<T>());
+                    entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+#endif
                     overload_set->entries.push_back(entry);
 
                 } (), ...);
@@ -11371,11 +13386,36 @@ class Namespace : public detail::Registrar
             {
                 ([&]
                 {
-                    using F = detail::constructor_forwarder<T, Functions>;
+                    using InnerF = detail::unwrap_fn_type_t<Functions>;
+                    using F = detail::constructor_forwarder<T, InnerF>;
 
-                    lua_newuserdata_aligned<F>(L, F(std::move(functions))); 
-                    lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1); 
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                    
+                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                    {
+                        
+                        using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<InnerF>>;
+                        detail::OverloadEntry entry;
+                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<InnerF, lua_State*>) - 1;
+                        entry.checker = &detail::overload_type_checker<ArgsPack>;
+                        entry.returnType = std::string(detail::typeName<T>());
+                        entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        if constexpr (detail::is_function_with_hints_v<Functions>)
+                            entry.paramHints = functions.hints;
+                        overload_set->entries.push_back(std::move(entry));
+                    }
 
+                    lua_createtable(L, 1, 0);
+                    lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions))));
+                    lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1);
+                    lua_rawseti(L, -2, 1);
+                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, className, 2);
+#else
+                    lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions)))); 
+                    lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1); 
+#endif
                 } (), ...);
             }
             else
@@ -11386,8 +13426,10 @@ class Namespace : public detail::Registrar
 
                 ([&]
                 {
+                    using InnerF = detail::unwrap_fn_type_t<Functions>;
+
                     detail::OverloadEntry entry;
-                    if constexpr (detail::is_any_cfunction_pointer_v<Functions>)
+                    if constexpr (detail::is_any_cfunction_pointer_v<InnerF>)
                     {
                         entry.arity = -1;
                         entry.checker = nullptr;
@@ -11395,9 +13437,15 @@ class Namespace : public detail::Registrar
                     else
                     {
                         
-                        using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
-                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>) - 1;
+                        using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<InnerF>>;
+                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<InnerF, lua_State*>) - 1;
                         entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                        entry.returnType = std::string(detail::typeName<T>());
+                        entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        if constexpr (detail::is_function_with_hints_v<Functions>)
+                            entry.paramHints = functions.hints;
+#endif
                     }
                     overload_set->entries.push_back(entry);
 
@@ -11409,9 +13457,10 @@ class Namespace : public detail::Registrar
 
                 ([&]
                 {
-                    using F = detail::constructor_forwarder<T, Functions>;
+                    using InnerF = detail::unwrap_fn_type_t<Functions>;
+                    using F = detail::constructor_forwarder<T, InnerF>;
 
-                    lua_newuserdata_aligned<F>(L, F(std::move(functions)));
+                    lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions))));
                     lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1);
                     lua_rawseti(L, -2, idx++);
 
@@ -11926,11 +13975,44 @@ class Namespace : public detail::Registrar
 
         if constexpr (sizeof...(Functions) == 1)
         {
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+            
+            ([&]
+            {
+                auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                detail::OverloadEntry entry;
+                if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
+                {
+                    using ArgsPack = detail::function_arguments_t<Functions>;
+                    entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
+                    entry.checker = &detail::overload_type_checker<ArgsPack>;
+                    entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                    entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                    if constexpr (detail::is_function_with_hints_v<Functions>)
+                        entry.paramHints = functions.hints;
+                }
+                else
+                {
+                    entry.arity = -1;
+                    entry.checker = nullptr;
+                }
+                overload_set->entries.push_back(std::move(entry));
+
+                lua_createtable(L, 1, 0);
+                detail::push_function(L, detail::get_underlying(std::move(functions)), name);
+                lua_rawseti(L, -2, 1);
+                lua_pushcclosure_x(L, &detail::try_overload_functions<false>, name, 2);
+
+            } (), ...);
+#else
             ([&]
             {
-                detail::push_function(L, std::move(functions), name);
+                detail::push_function(L, detail::get_underlying(std::move(functions)), name);
 
             } (), ...);
+#endif
         }
         else
         {
@@ -11951,6 +14033,12 @@ class Namespace : public detail::Registrar
                     using ArgsPack = detail::function_arguments_t<Functions>;
                     entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                     entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                    entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                    entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                    if constexpr (detail::is_function_with_hints_v<Functions>)
+                        entry.paramHints = functions.hints;
+#endif
                 }
                 overload_set->entries.push_back(entry);
 
@@ -11962,7 +14050,7 @@ class Namespace : public detail::Registrar
 
             ([&]
             {
-                detail::push_function(L, std::move(functions), name);
+                detail::push_function(L, detail::get_underlying(std::move(functions)), name);
                 lua_rawseti(L, -2, idx++);
 
             } (), ...);
@@ -11975,6 +14063,22 @@ class Namespace : public detail::Registrar
         return *this;
     }
 
+#if LUABRIDGE_HAS_CXX20_COROUTINES
+    
+    template <class F>
+    auto addCoroutine(const char* name, F factory)
+        -> std::enable_if_t<detail::is_cpp_coroutine_factory_v<F>, Namespace&>
+    {
+        LUABRIDGE_ASSERT(name != nullptr);
+        LUABRIDGE_ASSERT(lua_istable(L, -1)); 
+
+        detail::push_coroutine_function(L, std::move(factory), name);
+        rawsetfield(L, -2, name);
+
+        return *this;
+    }
+#endif 
+
     Table beginTable(const char* name)
     {
         assertIsActive();
diff --git a/Images/benchmarks.png b/Images/benchmarks.png
index f015a46a20e74f8aa656d0cac374147d7256844c..50009c8bad9921ffc1021db4bc3ea3e68b9f2e90 100644
GIT binary patch
literal 168214
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

literal 170105
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
B6E6S&

diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index 4503fafe..54271565 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -3,6 +3,7 @@ cmake_minimum_required (VERSION 3.10)
 set (LUABRIDGE_HEADERS
   ${CMAKE_CURRENT_SOURCE_DIR}/LuaBridge/Array.h
   ${CMAKE_CURRENT_SOURCE_DIR}/LuaBridge/Dump.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/LuaBridge/Inspect.h
   ${CMAKE_CURRENT_SOURCE_DIR}/LuaBridge/List.h
   ${CMAKE_CURRENT_SOURCE_DIR}/LuaBridge/LuaBridge.h
   ${CMAKE_CURRENT_SOURCE_DIR}/LuaBridge/Map.h
diff --git a/Source/LuaBridge/Inspect.h b/Source/LuaBridge/Inspect.h
new file mode 100644
index 00000000..d8a4a8a5
--- /dev/null
+++ b/Source/LuaBridge/Inspect.h
@@ -0,0 +1,1440 @@
+// https://github.com/kunitoki/LuaBridge3
+// Copyright 2026, kunitoki
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "detail/CFunctions.h"
+#include "detail/ClassInfo.h"
+#include "detail/LuaHelpers.h"
+
+#include <iostream>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace luabridge {
+
+//=================================================================================================
+// Forward declarations
+
+struct NamespaceInspectInfo;
+struct ClassInspectInfo;
+class InspectVisitor;
+
+void accept(const NamespaceInspectInfo& ns, InspectVisitor& v);
+void accept(const ClassInspectInfo& cls, InspectVisitor& v);
+
+//=================================================================================================
+/**
+ * @brief Kind of a registered member.
+ */
+enum class MemberKind
+{
+    Method,
+    StaticMethod,
+    Property,
+    ReadOnlyProperty,
+    StaticProperty,
+    StaticReadOnlyProperty,
+    Constructor,
+    Metamethod,
+};
+
+//=================================================================================================
+/**
+ * @brief Type and optional name hint for one Lua-visible parameter of an overload.
+ */
+struct ParamInfo
+{
+    std::string typeName; ///< C++ type name (e.g. "float", "int", "MyClass"). Empty if unavailable.
+    std::string hint;     ///< Optional user-provided name (e.g. "damage"). Empty if not provided.
+};
+
+//=================================================================================================
+/**
+ * @brief Type information for one overload of a registered function or constructor.
+ */
+struct OverloadInfo
+{
+    std::string returnType;        ///< C++ return type name. Empty if unavailable.
+    std::vector<ParamInfo> params; ///< One entry per Lua-visible parameter.
+    bool isConst = false;          ///< True when this is a const member function.
+};
+
+//=================================================================================================
+/**
+ * @brief Information about one registered member (method, property, constructor, …).
+ */
+struct MemberInfo
+{
+    std::string name;
+    MemberKind kind = MemberKind::Method;
+    std::vector<OverloadInfo> overloads; ///< At least 1 entry; may contain empty OverloadInfo.
+};
+
+//=================================================================================================
+/**
+ * @brief Inspection result for one registered class.
+ */
+struct ClassInspectInfo
+{
+    std::string name;
+    std::vector<std::string> baseClasses; ///< Names of all registered ancestor classes.
+    std::vector<MemberInfo> members;
+
+    void accept(InspectVisitor& v) const;
+};
+
+//=================================================================================================
+/**
+ * @brief Inspection result for a namespace (may contain classes and sub-namespaces).
+ */
+struct NamespaceInspectInfo
+{
+    std::string name;
+    std::vector<MemberInfo> freeMembers;                  ///< Free functions and namespace-level properties.
+    std::vector<ClassInspectInfo> classes;
+    std::vector<NamespaceInspectInfo> subNamespaces;
+
+    void accept(InspectVisitor& v) const;
+};
+
+//=================================================================================================
+/**
+ * @brief Visitor interface for traversing an inspection result tree.
+ *
+ * Override the methods you care about. Default implementations are no-ops so you only
+ * need to override what you need.
+ */
+class InspectVisitor
+{
+public:
+    virtual ~InspectVisitor() = default;
+
+    virtual void beginNamespace(const NamespaceInspectInfo& /*ns*/) {}
+    virtual void endNamespace(const NamespaceInspectInfo& /*ns*/) {}
+    virtual void visitFreeMember(const NamespaceInspectInfo& /*ns*/, const MemberInfo& /*m*/) {}
+
+    virtual void beginClass(const ClassInspectInfo& /*cls*/) {}
+    virtual void endClass(const ClassInspectInfo& /*cls*/) {}
+    virtual void visitMember(const ClassInspectInfo& /*cls*/, const MemberInfo& /*m*/) {}
+};
+
+//=================================================================================================
+/**
+ * @brief Traverse a namespace inspection result, calling visitor callbacks in order.
+ */
+inline void accept(const NamespaceInspectInfo& ns, InspectVisitor& v)
+{
+    v.beginNamespace(ns);
+    for (const auto& m : ns.freeMembers)
+        v.visitFreeMember(ns, m);
+    for (const auto& cls : ns.classes)
+        accept(cls, v);
+    for (const auto& sub : ns.subNamespaces)
+        accept(sub, v);
+    v.endNamespace(ns);
+}
+
+inline void accept(const ClassInspectInfo& cls, InspectVisitor& v)
+{
+    v.beginClass(cls);
+    for (const auto& m : cls.members)
+        v.visitMember(cls, m);
+    v.endClass(cls);
+}
+
+inline void ClassInspectInfo::accept(InspectVisitor& v) const { luabridge::accept(*this, v); }
+inline void NamespaceInspectInfo::accept(InspectVisitor& v) const { luabridge::accept(*this, v); }
+
+//=================================================================================================
+// Internal helpers
+
+namespace detail {
+
+// Read all string keys from a Lua table at tableIdx into a set
+inline std::set<std::string> collectTableKeys(lua_State* L, int tableIdx)
+{
+    std::set<std::string> keys;
+    tableIdx = lua_absindex(L, tableIdx);
+    lua_pushnil(L);
+    while (lua_next(L, tableIdx))
+    {
+        if (lua_type(L, -2) == LUA_TSTRING)
+            keys.insert(lua_tostring(L, -2));
+        lua_pop(L, 1); // pop value, keep key
+    }
+    return keys;
+}
+
+// Strip a "const " prefix from a type name string
+inline std::string stripConst(const char* name)
+{
+    std::string s = name ? name : "";
+    if (s.substr(0, 6) == "const ")
+        s = s.substr(6);
+    return s;
+}
+
+// Return the overload infos for a function/closure sitting at funcIdx.
+// If there's no OverloadSet upvalue (bare cfunction), returns 1 entry with empty type strings.
+inline std::vector<OverloadInfo> getOverloadInfos(lua_State* L, int funcIdx)
+{
+    funcIdx = lua_absindex(L, funcIdx);
+
+    if (!lua_isfunction(L, funcIdx))
+        return { OverloadInfo{} };
+
+    // Check upvalue 1 for an OverloadSet userdata
+    const char* uv1name = lua_getupvalue(L, funcIdx, 1);
+    if (uv1name == nullptr)
+    {
+        // No upvalues — bare cfunction (single function, no metadata available)
+        return { OverloadInfo{} };
+    }
+
+    bool isOverloadSet = isfulluserdata(L, -1);
+    lua_pop(L, 1); // pop upvalue 1
+
+    if (!isOverloadSet)
+    {
+        // upvalue 1 is not a full userdata (e.g. lightuserdata function pointer)
+        return { OverloadInfo{} };
+    }
+
+    // Confirm upvalue 2 is a table (the flat function table)
+    const char* uv2name = lua_getupvalue(L, funcIdx, 2);
+    bool hasTable = (uv2name != nullptr) && lua_istable(L, -1);
+    if (uv2name != nullptr)
+        lua_pop(L, 1); // pop upvalue 2
+
+    if (!hasTable)
+        return { OverloadInfo{} };
+
+    // Re-fetch upvalue 1 to read the OverloadSet
+    lua_getupvalue(L, funcIdx, 1);
+    auto* overload_set = align<OverloadSet>(lua_touserdata(L, -1));
+    lua_pop(L, 1);
+
+    if (!overload_set || overload_set->entries.empty())
+        return { OverloadInfo{} };
+
+    std::vector<OverloadInfo> result;
+    result.reserve(overload_set->entries.size());
+
+    for (const auto& entry : overload_set->entries)
+    {
+        OverloadInfo info;
+
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+        info.returnType = entry.returnType;
+        for (std::size_t i = 0; i < entry.paramTypes.size(); ++i)
+        {
+            ParamInfo p;
+            p.typeName = entry.paramTypes[i];
+            if (i < entry.paramHints.size())
+                p.hint = entry.paramHints[i];
+            info.params.push_back(std::move(p));
+        }
+#else
+        // Without LUABRIDGE_ENABLE_REFLECT: emit synthetic params based on arity only
+        if (entry.arity >= 0)
+        {
+            for (int i = 0; i < entry.arity; ++i)
+                info.params.push_back(ParamInfo{});
+        }
+#endif
+
+        result.push_back(std::move(info));
+    }
+
+    return result;
+}
+
+// Returns true if the table at tableIdx is a class static table (has a metatable with getClassKey).
+// Also leaves the class metatable (mt) on the stack top if true (caller must pop it).
+// Leaves nothing extra on the stack if false.
+inline bool isClassStaticTable(lua_State* L, int tableIdx)
+{
+    tableIdx = lua_absindex(L, tableIdx);
+
+    if (!lua_getmetatable(L, tableIdx)) // always works from C regardless of __metatable
+        return false;
+
+    lua_rawgetp(L, -1, getClassKey()); // mt[getClassKey()] = cl ?
+    bool result = lua_istable(L, -1);
+    lua_pop(L, 1); // pop cl / nil
+
+    if (!result)
+    {
+        lua_pop(L, 1); // pop mt
+        return false;
+    }
+
+    // Leave mt on stack (caller needs it)
+    return true;
+}
+
+// Inspect a class from its static table (st at stIdx).
+// Assumes isClassStaticTable(L, stIdx) returned true and left mt on the stack.
+inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
+{
+    stIdx = lua_absindex(L, stIdx);
+
+    // mt is on top of the stack (left there by isClassStaticTable)
+    int mtIdx = lua_absindex(L, -1);
+
+    // Get the class table cl = mt[getClassKey()]
+    lua_rawgetp(L, mtIdx, getClassKey());
+    int clIdx = lua_absindex(L, -1);
+
+    ClassInspectInfo cls;
+
+    // 1. Class name
+    lua_rawgetp(L, clIdx, getTypeKey());
+    if (lua_isstring(L, -1))
+        cls.name = stripConst(lua_tostring(L, -1));
+    lua_pop(L, 1);
+
+    // 2. Base classes from parent list
+    lua_rawgetp(L, clIdx, getParentKey());
+    if (lua_istable(L, -1))
+    {
+        int parIdx = lua_absindex(L, -1);
+        int len = static_cast<int>(luaL_len(L, parIdx));
+        for (int i = 1; i <= len; ++i)
+        {
+            lua_rawgeti(L, parIdx, i);
+            lua_rawgetp(L, -1, getTypeKey());
+            if (lua_isstring(L, -1))
+            {
+                std::string baseName = stripConst(lua_tostring(L, -1));
+                if (!baseName.empty() && baseName != cls.name)
+                    cls.baseClasses.push_back(std::move(baseName));
+            }
+            lua_pop(L, 2); // pop typename + parent mt
+        }
+    }
+    lua_pop(L, 1); // pop parent list / nil
+
+    // 3. Collect instance property names
+    std::set<std::string> instPropget;
+    lua_rawgetp(L, clIdx, getPropgetKey());
+    if (lua_istable(L, -1))
+        instPropget = collectTableKeys(L, -1);
+    lua_pop(L, 1);
+
+    // Collect instance property names that have a real (non-readonly-sentinel) setter
+    std::set<std::string> instPropsetReal;
+    lua_rawgetp(L, clIdx, getPropsetKey());
+    if (lua_istable(L, -1))
+    {
+        int psIdx = lua_absindex(L, -1);
+        for (const auto& k : instPropget)
+        {
+            lua_getfield(L, psIdx, k.c_str());
+            if (lua_isfunction(L, -1))
+            {
+                lua_CFunction fn = lua_tocfunction(L, -1);
+                if (fn != &detail::read_only_error)
+                    instPropsetReal.insert(k);
+            }
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1);
+
+    // 4. Emit instance properties
+    for (const auto& propName : instPropget)
+    {
+        MemberInfo m;
+        m.name = propName;
+        m.kind = instPropsetReal.count(propName) ? MemberKind::Property : MemberKind::ReadOnlyProperty;
+        m.overloads.push_back(OverloadInfo{});
+        cls.members.push_back(std::move(m));
+    }
+
+    // 5. Iterate class table for instance methods / metamethods
+    static const std::set<std::string> skipKeys{ "__index", "__newindex", "__metatable" };
+
+    lua_pushnil(L);
+    while (lua_next(L, clIdx))
+    {
+        if (lua_type(L, -2) == LUA_TSTRING)
+        {
+            std::string key = lua_tostring(L, -2);
+            if (!skipKeys.count(key) && !instPropget.count(key))
+            {
+                if (lua_isfunction(L, -1) || lua_isuserdata(L, -1))
+                {
+                    MemberInfo m;
+                    m.name = key;
+                    m.kind = (key.size() >= 2 && key[0] == '_' && key[1] == '_')
+                        ? MemberKind::Metamethod
+                        : MemberKind::Method;
+                    m.overloads = getOverloadInfos(L, -1);
+                    cls.members.push_back(std::move(m));
+                }
+            }
+        }
+        lua_pop(L, 1); // pop value
+    }
+
+    // 6. Collect static property names
+    std::set<std::string> stPropget;
+    lua_rawgetp(L, mtIdx, getPropgetKey());
+    if (lua_istable(L, -1))
+        stPropget = collectTableKeys(L, -1);
+    lua_pop(L, 1);
+
+    // Collect static property names that have a real (non-readonly-sentinel) setter
+    std::set<std::string> stPropsetReal;
+    lua_rawgetp(L, mtIdx, getPropsetKey());
+    if (lua_istable(L, -1))
+    {
+        int psIdx = lua_absindex(L, -1);
+        for (const auto& k : stPropget)
+        {
+            lua_getfield(L, psIdx, k.c_str());
+            if (lua_isfunction(L, -1))
+            {
+                lua_CFunction fn = lua_tocfunction(L, -1);
+                if (fn != &detail::read_only_error)
+                    stPropsetReal.insert(k);
+            }
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1);
+
+    // 7. Emit static properties
+    for (const auto& propName : stPropget)
+    {
+        MemberInfo m;
+        m.name = propName;
+        m.kind = stPropsetReal.count(propName) ? MemberKind::StaticProperty : MemberKind::StaticReadOnlyProperty;
+        m.overloads.push_back(OverloadInfo{});
+        cls.members.push_back(std::move(m));
+    }
+
+    // 8. Iterate mt for static methods + constructor
+    static const std::set<std::string> staticSkipKeys{ "__index", "__newindex", "__metatable" };
+
+    lua_rawgetp(L, mtIdx, getClassKey()); // just to see mt's string keys, iterate mt directly
+    lua_pop(L, 1);
+
+    lua_pushnil(L);
+    while (lua_next(L, mtIdx))
+    {
+        if (lua_type(L, -2) == LUA_TSTRING)
+        {
+            std::string key = lua_tostring(L, -2);
+            if (!staticSkipKeys.count(key) && !stPropget.count(key))
+            {
+                if (lua_isfunction(L, -1) || lua_isuserdata(L, -1))
+                {
+                    MemberInfo m;
+                    m.name = key;
+                    if (key == "__call")
+                        m.kind = MemberKind::Constructor;
+                    else if (key.size() >= 2 && key[0] == '_' && key[1] == '_')
+                        m.kind = MemberKind::Metamethod;
+                    else
+                        m.kind = MemberKind::StaticMethod;
+                    m.overloads = getOverloadInfos(L, -1);
+                    cls.members.push_back(std::move(m));
+                }
+            }
+        }
+        lua_pop(L, 1);
+    }
+
+    lua_pop(L, 2); // pop cl, mt
+    return cls;
+}
+
+// Inspect a namespace table at nsIdx
+inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::string name);
+
+inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::string name)
+{
+    nsIdx = lua_absindex(L, nsIdx);
+    NamespaceInspectInfo info;
+    info.name = std::move(name);
+
+    // Namespace-level properties (stored directly on the namespace table via getPropgetKey)
+    std::set<std::string> nsPropget;
+    lua_rawgetp(L, nsIdx, getPropgetKey());
+    if (lua_istable(L, -1))
+        nsPropget = collectTableKeys(L, -1);
+    lua_pop(L, 1);
+
+    // Get the propset table so we can check each setter individually
+    int nsPropsetTableIdx = 0;
+    lua_rawgetp(L, nsIdx, getPropsetKey());
+    if (lua_istable(L, -1))
+        nsPropsetTableIdx = lua_absindex(L, -1);
+    // leave propset table on stack; we pop it after the loop
+
+    for (const auto& propName : nsPropget)
+    {
+        MemberInfo m;
+        m.name = propName;
+
+        // A getter-only namespace property still gets a read_only_error sentinel in propset.
+        // Detect the sentinel by comparing the setter's underlying C function pointer.
+        bool isReadOnly = true;
+        if (nsPropsetTableIdx)
+        {
+            lua_getfield(L, nsPropsetTableIdx, propName.c_str());
+            if (lua_isfunction(L, -1))
+            {
+                lua_CFunction fn = lua_tocfunction(L, -1);
+                isReadOnly = (fn == &detail::read_only_error);
+            }
+            lua_pop(L, 1);
+        }
+
+        m.kind = isReadOnly ? MemberKind::ReadOnlyProperty : MemberKind::Property;
+        m.overloads.push_back(OverloadInfo{});
+        info.freeMembers.push_back(std::move(m));
+    }
+
+    lua_pop(L, 1); // pop propset table (or nil)
+
+    // Iterate namespace table entries
+    static const std::set<std::string> nsSkipKeys{ "__index", "__newindex", "__metatable", "__gc" };
+
+    lua_pushnil(L);
+    while (lua_next(L, nsIdx))
+    {
+        if (lua_type(L, -2) != LUA_TSTRING)
+        {
+            lua_pop(L, 1);
+            continue;
+        }
+
+        std::string key = lua_tostring(L, -2);
+
+        if (nsSkipKeys.count(key) || nsPropget.count(key))
+        {
+            lua_pop(L, 1);
+            continue;
+        }
+
+        if (lua_istable(L, -1))
+        {
+            int valIdx = lua_absindex(L, -1);
+
+            if (isClassStaticTable(L, valIdx))
+            {
+                // mt is now on top of the stack (left by isClassStaticTable)
+                auto cls = inspectClassFromStaticTable(L, valIdx);
+                // inspectClassFromStaticTable pops mt and cl
+                info.classes.push_back(std::move(cls));
+            }
+            else
+            {
+                auto sub = inspectNamespaceTable(L, valIdx, key);
+                info.subNamespaces.push_back(std::move(sub));
+            }
+        }
+        else if (lua_isfunction(L, -1))
+        {
+            if (!nsPropget.count(key))
+            {
+                MemberInfo m;
+                m.name = key;
+                m.kind = MemberKind::Method;
+                m.overloads = getOverloadInfos(L, -1);
+                info.freeMembers.push_back(std::move(m));
+            }
+        }
+
+        lua_pop(L, 1); // pop value
+    }
+
+    return info;
+}
+
+} // namespace detail
+
+//=================================================================================================
+/**
+ * @brief Inspect a single registered class by its C++ type.
+ *
+ * Uses the compile-time registry key — no namespace traversal required.
+ *
+ * @returns Inspection result, or an empty ClassInspectInfo if T is not registered.
+ */
+template <class T>
+[[nodiscard]] ClassInspectInfo inspect(lua_State* L)
+{
+    // Load the class table (cl) directly from the Lua registry
+    lua_rawgetp(L, LUA_REGISTRYINDEX, detail::getClassRegistryKey<T>());
+    if (!lua_istable(L, -1))
+    {
+        lua_pop(L, 1);
+        return {};
+    }
+    // Stack: ..., cl
+
+    // cl[getStaticKey()] = st  (the internal static table that acts as a metatable)
+    // NOTE: this is NOT the user-visible ns["ClassName"] table; it is the metatable of that table.
+    // isClassStaticTable() cannot be used here because st itself has no metatable.
+    lua_rawgetp(L, -1, detail::getStaticKey());
+    if (!lua_istable(L, -1))
+    {
+        lua_pop(L, 2);
+        return {};
+    }
+    // Stack: ..., cl, st
+
+    // Verify st actually belongs to a registered class: st[getClassKey()] must be a table
+    lua_rawgetp(L, -1, detail::getClassKey());
+    const bool isClass = lua_istable(L, -1);
+    lua_pop(L, 1);
+
+    if (!isClass)
+    {
+        lua_pop(L, 2);
+        return {};
+    }
+    // Stack: ..., cl, st  (st is at top — inspectClassFromStaticTable reads it as "mt")
+
+    ClassInspectInfo result = detail::inspectClassFromStaticTable(L, lua_gettop(L));
+    // inspectClassFromStaticTable pops st (used as mt) and the cl it fetched from st[getClassKey()]
+    // Stack: ..., cl
+
+    lua_pop(L, 1); // pop cl
+    return result;
+}
+
+//=================================================================================================
+/**
+ * @brief Inspect a namespace by name.
+ *
+ * @param namespaceName The global name of the namespace (e.g. "MyNS"), or nullptr / "" for the
+ *                      global namespace. Supports dotted paths ("Outer.Inner").
+ *
+ * @returns Inspection result, or an empty NamespaceInspectInfo if the name is not found.
+ */
+[[nodiscard]] inline NamespaceInspectInfo inspectNamespace(lua_State* L, const char* namespaceName = nullptr)
+{
+    if (namespaceName == nullptr || namespaceName[0] == '\0')
+    {
+        lua_pushglobaltable(L);
+    }
+    else
+    {
+        // Support dotted paths by navigating component by component
+        std::string path = namespaceName;
+        std::string first;
+        std::string::size_type dot = path.find('.');
+        if (dot == std::string::npos)
+            first = path;
+        else
+            first = path.substr(0, dot);
+
+        lua_getglobal(L, first.c_str());
+        if (!lua_istable(L, -1))
+        {
+            lua_pop(L, 1);
+            return {};
+        }
+
+        while (dot != std::string::npos)
+        {
+            path = path.substr(dot + 1);
+            dot = path.find('.');
+            std::string component = (dot == std::string::npos) ? path : path.substr(0, dot);
+            lua_getfield(L, -1, component.c_str());
+            lua_remove(L, -2); // remove previous table
+            if (!lua_istable(L, -1))
+            {
+                lua_pop(L, 1);
+                return {};
+            }
+        }
+    }
+
+    // Use only the leaf component of a dotted path as the display name
+    std::string label;
+    if (namespaceName && namespaceName[0])
+    {
+        std::string_view sv(namespaceName);
+        auto dot = sv.rfind('.');
+        label = std::string(dot == std::string_view::npos ? sv : sv.substr(dot + 1));
+    }
+    else
+    {
+        label = "_G";
+    }
+    auto result = detail::inspectNamespaceTable(L, -1, label);
+    lua_pop(L, 1);
+    return result;
+}
+
+//=================================================================================================
+/**
+ * @brief Collect inspection data for a namespace and drive a visitor over it.
+ */
+inline void inspectAccept(lua_State* L, const char* namespaceName, InspectVisitor& visitor)
+{
+    auto ns = inspectNamespace(L, namespaceName);
+    accept(ns, visitor);
+}
+
+//=================================================================================================
+// Built-in visitors
+
+//=================================================================================================
+/**
+ * @brief Visitor that emits TypeScript-style pseudo-code to an ostream.
+ *
+ * Useful for quick debugging and documentation.
+ *
+ * Example output:
+ * @code
+ * namespace MyNS {
+ *     class Foo extends Base {
+ *         constructor();
+ *         method(p1: float): void;
+ *         readonly value: int;
+ *         static create(): Foo;
+ *     }
+ * }
+ * @endcode
+ */
+class ConsoleVisitor : public InspectVisitor
+{
+public:
+    explicit ConsoleVisitor(std::ostream& out = std::cerr)
+        : out_(out)
+    {
+    }
+
+    void beginNamespace(const NamespaceInspectInfo& ns) override
+    {
+        indent();
+        out_ << "namespace " << ns.name << " {\n";
+        ++depth_;
+    }
+
+    void endNamespace(const NamespaceInspectInfo& /*ns*/) override
+    {
+        --depth_;
+        indent();
+        out_ << "}\n";
+    }
+
+    void visitFreeMember(const NamespaceInspectInfo& /*ns*/, const MemberInfo& m) override
+    {
+        emitMember(m, /*className=*/"");
+    }
+
+    void beginClass(const ClassInspectInfo& cls) override
+    {
+        indent();
+        out_ << "class " << cls.name;
+        if (!cls.baseClasses.empty())
+        {
+            out_ << " extends ";
+            for (std::size_t i = 0; i < cls.baseClasses.size(); ++i)
+            {
+                if (i) out_ << ", ";
+                out_ << cls.baseClasses[i];
+            }
+        }
+        out_ << " {\n";
+        ++depth_;
+    }
+
+    void endClass(const ClassInspectInfo& /*cls*/) override
+    {
+        --depth_;
+        indent();
+        out_ << "}\n";
+    }
+
+    void visitMember(const ClassInspectInfo& cls, const MemberInfo& m) override
+    {
+        emitMember(m, cls.name);
+    }
+
+private:
+    void indent() const
+    {
+        for (int i = 0; i < depth_; ++i)
+            out_ << "    ";
+    }
+
+    static std::string paramStr(const OverloadInfo& ov)
+    {
+        std::string s;
+        for (std::size_t i = 0; i < ov.params.size(); ++i)
+        {
+            if (i) s += ", ";
+            const auto& p = ov.params[i];
+            s += p.hint.empty() ? ("p" + std::to_string(i + 1)) : p.hint;
+            s += ": ";
+            s += p.typeName.empty() ? "any" : p.typeName;
+        }
+        return s;
+    }
+
+    static std::string retStr(const OverloadInfo& ov, const std::string& constructorClass = "")
+    {
+        if (!constructorClass.empty())
+            return constructorClass;
+        return ov.returnType.empty() ? "any" : ov.returnType;
+    }
+
+    void emitMember(const MemberInfo& m, const std::string& className) const
+    {
+        switch (m.kind)
+        {
+        case MemberKind::Property:
+            indent(); out_ << m.name << ": any;\n"; break;
+        case MemberKind::ReadOnlyProperty:
+            indent(); out_ << "readonly " << m.name << ": any;\n"; break;
+        case MemberKind::StaticProperty:
+            indent(); out_ << "static " << m.name << ": any;\n"; break;
+        case MemberKind::StaticReadOnlyProperty:
+            indent(); out_ << "static readonly " << m.name << ": any;\n"; break;
+        case MemberKind::Metamethod:
+            // Skip metamethods in TypeScript-style output
+            break;
+        case MemberKind::Constructor:
+            for (const auto& ov : m.overloads)
+            {
+                indent();
+                out_ << "constructor(" << paramStr(ov) << ");\n";
+            }
+            break;
+        case MemberKind::Method:
+        case MemberKind::StaticMethod:
+        {
+            bool isStatic = (m.kind == MemberKind::StaticMethod);
+            for (std::size_t i = 0; i < m.overloads.size(); ++i)
+            {
+                indent();
+                if (isStatic) out_ << "static ";
+                out_ << m.name << "(" << paramStr(m.overloads[i]) << "): "
+                     << retStr(m.overloads[i]) << ";\n";
+            }
+            break;
+        }
+        default:
+            break;
+        }
+        (void)className;
+    }
+
+    std::ostream& out_;
+    int depth_ = 0;
+};
+
+//=================================================================================================
+/**
+ * @brief Visitor that emits LuaLS (Lua Language Server) / LuaCATS annotation stubs.
+ *
+ * Suitable for generating `.lua` type stub files consumed by lua-language-server.
+ *
+ * @see https://luals.github.io/wiki/annotations/
+ */
+class LuaLSVisitor : public InspectVisitor
+{
+public:
+    explicit LuaLSVisitor(std::ostream& out)
+        : out_(out)
+    {
+    }
+
+    void beginNamespace(const NamespaceInspectInfo& ns) override
+    {
+        ns_ = ns.name == "_G" ? "" : ns.name;
+    }
+
+    void endNamespace(const NamespaceInspectInfo& /*ns*/) override {}
+
+    void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) override
+    {
+        if (m.kind != MemberKind::Method && m.kind != MemberKind::StaticMethod)
+            return; // properties not directly emittable as LuaLS annotations easily
+
+        for (const auto& ov : m.overloads)
+        {
+            emitParams(ov.params);
+            if (!ov.returnType.empty() && ov.returnType != "void")
+                out_ << "---@return " << luaType(ov.returnType) << "\n";
+        }
+        std::string qual = ns_.empty() ? "" : (ns_ + ".");
+        out_ << "function " << qual << m.name << "(";
+        if (!m.overloads.empty())
+            out_ << paramNames(m.overloads[0].params);
+        out_ << ") end\n\n";
+    }
+
+    void beginClass(const ClassInspectInfo& cls) override
+    {
+        curClass_ = cls.name;
+        out_ << "---@class " << qualifiedName(cls.name);
+        if (!cls.baseClasses.empty())
+        {
+            out_ << " : " << cls.baseClasses[0];
+            for (std::size_t i = 1; i < cls.baseClasses.size(); ++i)
+                out_ << ", " << cls.baseClasses[i];
+        }
+        out_ << "\n";
+
+        // Emit fields for properties in the class body annotation
+        // (will be added in visitMember below, but need the class annotation open)
+    }
+
+    void endClass(const ClassInspectInfo& /*cls*/) override
+    {
+        out_ << "local " << curClass_ << " = {}\n\n";
+        curClass_.clear();
+    }
+
+    void visitMember(const ClassInspectInfo& cls, const MemberInfo& m) override
+    {
+        switch (m.kind)
+        {
+        case MemberKind::Property:
+            out_ << "---@field " << m.name << " any\n";
+            break;
+        case MemberKind::ReadOnlyProperty:
+            out_ << "---@field " << m.name << " any # readonly\n";
+            break;
+        case MemberKind::StaticProperty:
+            out_ << "---@field " << m.name << " any\n";
+            break;
+        case MemberKind::StaticReadOnlyProperty:
+            out_ << "---@field " << m.name << " any # readonly\n";
+            break;
+        case MemberKind::Constructor:
+        {
+            out_ << "\n";
+            for (std::size_t i = 0; i < m.overloads.size(); ++i)
+            {
+                const auto& ov = m.overloads[i];
+                if (i == 0)
+                {
+                    emitParams(ov.params);
+                    out_ << "---@return " << cls.name << "\n";
+                    out_ << "function " << cls.name << ".new(" << paramNames(ov.params) << ") end\n";
+                }
+                else
+                {
+                    out_ << "---@overload fun(" << overloadParams(ov.params) << "): " << cls.name << "\n";
+                }
+            }
+            break;
+        }
+        case MemberKind::Method:
+        {
+            out_ << "\n";
+            for (std::size_t i = 0; i < m.overloads.size(); ++i)
+            {
+                const auto& ov = m.overloads[i];
+                if (i == 0)
+                {
+                    emitParams(ov.params, /*hasSelf=*/true);
+                    if (!ov.returnType.empty() && ov.returnType != "void")
+                        out_ << "---@return " << luaType(ov.returnType) << "\n";
+                    out_ << "function " << cls.name << ":" << m.name
+                         << "(" << paramNames(ov.params) << ") end\n";
+                }
+                else
+                {
+                    out_ << "---@overload fun(self: " << cls.name << ", " << overloadParams(ov.params) << ")"
+                         << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
+                }
+            }
+            break;
+        }
+        case MemberKind::StaticMethod:
+        {
+            out_ << "\n";
+            for (std::size_t i = 0; i < m.overloads.size(); ++i)
+            {
+                const auto& ov = m.overloads[i];
+                if (i == 0)
+                {
+                    emitParams(ov.params);
+                    if (!ov.returnType.empty() && ov.returnType != "void")
+                        out_ << "---@return " << luaType(ov.returnType) << "\n";
+                    out_ << "function " << cls.name << "." << m.name
+                         << "(" << paramNames(ov.params) << ") end\n";
+                }
+                else
+                {
+                    out_ << "---@overload fun(" << overloadParams(ov.params) << ")"
+                         << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
+                }
+            }
+            break;
+        }
+        default:
+            break;
+        }
+    }
+
+private:
+    // Minimal C++ → Lua type name mapping
+    static std::string luaType(const std::string& cppType)
+    {
+        if (cppType == "void") return "nil";
+        if (cppType == "bool") return "boolean";
+        if (cppType == "int" || cppType == "long" || cppType == "short" ||
+            cppType == "unsigned int" || cppType == "unsigned long" ||
+            cppType == "unsigned short" || cppType == "int64_t" || cppType == "uint64_t" ||
+            cppType == "int32_t" || cppType == "uint32_t" || cppType == "size_t")
+            return "integer";
+        if (cppType == "float" || cppType == "double") return "number";
+        if (cppType == "std::string" || cppType == "const char *" || cppType == "const char*")
+            return "string";
+        return cppType.empty() ? "any" : cppType;
+    }
+
+    std::string qualifiedName(const std::string& name) const
+    {
+        return ns_.empty() ? name : (ns_ + "." + name);
+    }
+
+    static std::string paramNames(const std::vector<ParamInfo>& params)
+    {
+        std::string s;
+        for (std::size_t i = 0; i < params.size(); ++i)
+        {
+            if (i) s += ", ";
+            s += params[i].hint.empty() ? ("p" + std::to_string(i + 1)) : params[i].hint;
+        }
+        return s;
+    }
+
+    static std::string overloadParams(const std::vector<ParamInfo>& params)
+    {
+        std::string s;
+        for (std::size_t i = 0; i < params.size(); ++i)
+        {
+            if (i) s += ", ";
+            const auto& p = params[i];
+            std::string pname = p.hint.empty() ? ("p" + std::to_string(i + 1)) : p.hint;
+            s += pname + ": " + luaType(p.typeName.empty() ? "any" : p.typeName);
+        }
+        return s;
+    }
+
+    void emitParams(const std::vector<ParamInfo>& params, bool hasSelf = false) const
+    {
+        if (hasSelf)
+            out_ << "---@param self " << curClass_ << "\n";
+        for (std::size_t i = 0; i < params.size(); ++i)
+        {
+            const auto& p = params[i];
+            std::string pname = p.hint.empty() ? ("p" + std::to_string(i + 1)) : p.hint;
+            std::string ptype = p.typeName.empty() ? "any" : luaType(p.typeName);
+            out_ << "---@param " << pname << " " << ptype << "\n";
+        }
+    }
+
+    std::ostream& out_;
+    std::string ns_;
+    std::string curClass_;
+};
+
+//=================================================================================================
+/**
+ * @brief Visitor that emits a real Lua stub file (require()-able, mockable in tests).
+ *
+ * Each class is emitted as a module-local table with stub methods.
+ * Namespace-level functions are emitted as module-level functions.
+ */
+class LuaProxyVisitor : public InspectVisitor
+{
+public:
+    explicit LuaProxyVisitor(std::ostream& out)
+        : out_(out)
+    {
+    }
+
+    void beginNamespace(const NamespaceInspectInfo& ns) override
+    {
+        if (ns.name != "_G")
+            out_ << "local " << ns.name << " = {}\n\n";
+    }
+
+    void endNamespace(const NamespaceInspectInfo& ns) override
+    {
+        if (ns.name != "_G")
+            out_ << "return " << ns.name << "\n";
+    }
+
+    void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) override
+    {
+        if (m.kind != MemberKind::Method && m.kind != MemberKind::StaticMethod)
+            return;
+        std::string qual = (ns.name == "_G") ? "" : (ns.name + ".");
+        if (!m.overloads.empty())
+        {
+            out_ << "function " << qual << m.name
+                 << "(" << paramNames(m.overloads[0].params) << ") end\n";
+        }
+    }
+
+    void beginClass(const ClassInspectInfo& cls) override
+    {
+        curClass_ = cls.name;
+        out_ << cls.name << " = {}\n";
+        out_ << cls.name << ".__index = " << cls.name << "\n\n";
+    }
+
+    void endClass(const ClassInspectInfo& /*cls*/) override
+    {
+        curClass_.clear();
+        out_ << "\n";
+    }
+
+    void visitMember(const ClassInspectInfo& /*cls*/, const MemberInfo& m) override
+    {
+        if (m.overloads.empty())
+            return;
+
+        switch (m.kind)
+        {
+        case MemberKind::Constructor:
+            out_ << "function " << curClass_ << ".new("
+                 << paramNames(m.overloads[0].params) << ")\n"
+                 << "    return setmetatable({}, " << curClass_ << ")\n"
+                 << "end\n\n";
+            break;
+        case MemberKind::Method:
+            out_ << "function " << curClass_ << ":" << m.name
+                 << "(" << paramNames(m.overloads[0].params) << ") end\n";
+            break;
+        case MemberKind::StaticMethod:
+            out_ << "function " << curClass_ << "." << m.name
+                 << "(" << paramNames(m.overloads[0].params) << ") end\n";
+            break;
+        case MemberKind::Property:
+        case MemberKind::ReadOnlyProperty:
+        case MemberKind::StaticProperty:
+        case MemberKind::StaticReadOnlyProperty:
+            // Properties are part of the table, no explicit function needed
+            break;
+        default:
+            break;
+        }
+    }
+
+private:
+    static std::string paramNames(const std::vector<ParamInfo>& params)
+    {
+        std::string s;
+        for (std::size_t i = 0; i < params.size(); ++i)
+        {
+            if (i) s += ", ";
+            s += params[i].hint.empty() ? ("p" + std::to_string(i + 1)) : params[i].hint;
+        }
+        return s;
+    }
+
+    std::ostream& out_;
+    std::string curClass_;
+};
+
+//=================================================================================================
+/**
+ * @brief Visitor that emits a JSON representation of the inspection tree.
+ */
+class JsonVisitor : public InspectVisitor
+{
+public:
+    explicit JsonVisitor(std::ostream& out)
+        : out_(out)
+    {
+    }
+
+    void beginNamespace(const NamespaceInspectInfo& ns) override
+    {
+        if (depth_ == 0) out_ << "{\n";
+        indent(); out_ << "\"name\": \"" << escape(ns.name) << "\",\n";
+        indent(); out_ << "\"freeMembers\": [],\n";
+        indent(); out_ << "\"classes\": [\n";
+        ++depth_;
+        firstClass_ = true;
+    }
+
+    void endNamespace(const NamespaceInspectInfo& /*ns*/) override
+    {
+        --depth_;
+        out_ << "\n";
+        indent(); out_ << "]\n";
+        if (depth_ == 0) out_ << "}\n";
+    }
+
+    void beginClass(const ClassInspectInfo& cls) override
+    {
+        if (!firstClass_) out_ << ",\n";
+        firstClass_ = false;
+        indent(); out_ << "{\n";
+        ++depth_;
+        indent(); out_ << "\"name\": \"" << escape(cls.name) << "\",\n";
+        indent(); out_ << "\"bases\": [";
+        for (std::size_t i = 0; i < cls.baseClasses.size(); ++i)
+        {
+            if (i) out_ << ", ";
+            out_ << "\"" << escape(cls.baseClasses[i]) << "\"";
+        }
+        out_ << "],\n";
+        indent(); out_ << "\"members\": [\n";
+        ++depth_;
+        firstMember_ = true;
+    }
+
+    void endClass(const ClassInspectInfo& /*cls*/) override
+    {
+        --depth_;
+        out_ << "\n";
+        indent(); out_ << "]\n";
+        --depth_;
+        indent(); out_ << "}";
+    }
+
+    void visitMember(const ClassInspectInfo& /*cls*/, const MemberInfo& m) override
+    {
+        if (!firstMember_) out_ << ",\n";
+        firstMember_ = false;
+        indent();
+        out_ << "{ \"name\": \"" << escape(m.name) << "\""
+             << ", \"kind\": \"" << kindStr(m.kind) << "\""
+             << ", \"overloads\": " << m.overloads.size()
+             << " }";
+    }
+
+private:
+    void indent() const
+    {
+        for (int i = 0; i < depth_; ++i)
+            out_ << "  ";
+    }
+
+    static std::string escape(const std::string& s)
+    {
+        std::string out;
+        for (char c : s)
+        {
+            if (c == '"') out += "\\\"";
+            else if (c == '\\') out += "\\\\";
+            else out += c;
+        }
+        return out;
+    }
+
+    static const char* kindStr(MemberKind k)
+    {
+        switch (k)
+        {
+        case MemberKind::Method: return "method";
+        case MemberKind::StaticMethod: return "static_method";
+        case MemberKind::Property: return "property";
+        case MemberKind::ReadOnlyProperty: return "readonly_property";
+        case MemberKind::StaticProperty: return "static_property";
+        case MemberKind::StaticReadOnlyProperty: return "static_readonly_property";
+        case MemberKind::Constructor: return "constructor";
+        case MemberKind::Metamethod: return "metamethod";
+        default: return "unknown";
+        }
+    }
+
+    std::ostream& out_;
+    int depth_ = 0;
+    bool firstClass_ = true;
+    bool firstMember_ = true;
+};
+
+//=================================================================================================
+/**
+ * @brief Visitor that builds a structured Lua table on the Lua stack.
+ *
+ * After calling accept() with this visitor, the stack top is a table with structure:
+ * @code
+ * {
+ *   name = "MyNS",
+ *   freeMembers = { {name=…, kind=…, overloads=…}, … },
+ *   classes = {
+ *     { name=…, bases={…}, members={ {name=…, kind=…, overloads=N}, … } },
+ *     …
+ *   },
+ *   subNamespaces = { … }
+ * }
+ * @endcode
+ */
+class LuaTableVisitor : public InspectVisitor
+{
+public:
+    explicit LuaTableVisitor(lua_State* L)
+        : L_(L)
+    {
+    }
+
+    void beginNamespace(const NamespaceInspectInfo& ns) override
+    {
+        lua_newtable(L_); // the namespace table
+        lua_pushstring(L_, ns.name.c_str());
+        lua_setfield(L_, -2, "name");
+
+        lua_newtable(L_);
+        lua_setfield(L_, -2, "freeMembers");
+        freeMemberIdx_ = 1;
+
+        lua_newtable(L_);
+        lua_setfield(L_, -2, "classes");
+        classIdx_ = 1;
+
+        lua_newtable(L_);
+        lua_setfield(L_, -2, "subNamespaces");
+        subNsIdx_ = 1;
+    }
+
+    void endNamespace(const NamespaceInspectInfo& /*ns*/) override
+    {
+        // namespace table stays on stack as the result
+    }
+
+    void visitFreeMember(const NamespaceInspectInfo& /*ns*/, const MemberInfo& m) override
+    {
+        lua_getfield(L_, -1, "freeMembers");
+        pushMemberInfo(m);
+        lua_rawseti(L_, -2, freeMemberIdx_++);
+        lua_pop(L_, 1);
+    }
+
+    void beginClass(const ClassInspectInfo& cls) override
+    {
+        lua_newtable(L_);
+        lua_pushstring(L_, cls.name.c_str());
+        lua_setfield(L_, -2, "name");
+
+        lua_newtable(L_);
+        for (std::size_t i = 0; i < cls.baseClasses.size(); ++i)
+        {
+            lua_pushstring(L_, cls.baseClasses[i].c_str());
+            lua_rawseti(L_, -2, static_cast<int>(i + 1));
+        }
+        lua_setfield(L_, -2, "bases");
+
+        lua_newtable(L_);
+        lua_setfield(L_, -2, "members");
+        memberIdx_ = 1;
+    }
+
+    void endClass(const ClassInspectInfo& /*cls*/) override
+    {
+        // class table is on top; store it in the namespace's "classes" array
+        lua_getfield(L_, -2, "classes");
+        lua_pushvalue(L_, -2);
+        lua_rawseti(L_, -2, classIdx_++);
+        lua_pop(L_, 2); // pop classes table + class table
+    }
+
+    void visitMember(const ClassInspectInfo& /*cls*/, const MemberInfo& m) override
+    {
+        lua_getfield(L_, -1, "members");
+        pushMemberInfo(m);
+        lua_rawseti(L_, -2, memberIdx_++);
+        lua_pop(L_, 1);
+    }
+
+private:
+    void pushMemberInfo(const MemberInfo& m)
+    {
+        lua_newtable(L_);
+        lua_pushstring(L_, m.name.c_str());
+        lua_setfield(L_, -2, "name");
+        lua_pushstring(L_, kindStr(m.kind));
+        lua_setfield(L_, -2, "kind");
+        lua_pushinteger(L_, static_cast<lua_Integer>(m.overloads.size()));
+        lua_setfield(L_, -2, "overloads");
+
+        // Emit overload details when type info is available
+        lua_newtable(L_);
+        for (std::size_t i = 0; i < m.overloads.size(); ++i)
+        {
+            const auto& ov = m.overloads[i];
+            lua_newtable(L_);
+            lua_pushstring(L_, ov.returnType.c_str());
+            lua_setfield(L_, -2, "returnType");
+
+            lua_newtable(L_);
+            for (std::size_t j = 0; j < ov.params.size(); ++j)
+            {
+                lua_newtable(L_);
+                lua_pushstring(L_, ov.params[j].typeName.c_str());
+                lua_setfield(L_, -2, "type");
+                lua_pushstring(L_, ov.params[j].hint.c_str());
+                lua_setfield(L_, -2, "hint");
+                lua_rawseti(L_, -2, static_cast<int>(j + 1));
+            }
+            lua_setfield(L_, -2, "params");
+            lua_rawseti(L_, -2, static_cast<int>(i + 1));
+        }
+        lua_setfield(L_, -2, "overloadDetails");
+    }
+
+    static const char* kindStr(MemberKind k)
+    {
+        switch (k)
+        {
+        case MemberKind::Method: return "method";
+        case MemberKind::StaticMethod: return "static_method";
+        case MemberKind::Property: return "property";
+        case MemberKind::ReadOnlyProperty: return "readonly_property";
+        case MemberKind::StaticProperty: return "static_property";
+        case MemberKind::StaticReadOnlyProperty: return "static_readonly_property";
+        case MemberKind::Constructor: return "constructor";
+        case MemberKind::Metamethod: return "metamethod";
+        default: return "unknown";
+        }
+    }
+
+    lua_State* L_;
+    int freeMemberIdx_ = 1;
+    int classIdx_ = 1;
+    int subNsIdx_ = 1;
+    int memberIdx_ = 1;
+};
+
+//=================================================================================================
+/**
+ * @brief Print a TypeScript-style inspection of a namespace to an ostream.
+ *
+ * Convenience wrapper around ConsoleVisitor.
+ */
+inline void inspectPrint(lua_State* L, const char* namespaceName = nullptr, std::ostream& stream = std::cerr)
+{
+    auto ns = inspectNamespace(L, namespaceName);
+    ConsoleVisitor v(stream);
+    accept(ns, v);
+}
+
+//=================================================================================================
+/**
+ * @brief Push a structured Lua table describing a namespace onto the Lua stack.
+ *
+ * Convenience wrapper around LuaTableVisitor.
+ * Pushes exactly 1 value (the result table).
+ */
+inline void inspectToLua(lua_State* L, const char* namespaceName = nullptr)
+{
+    auto ns = inspectNamespace(L, namespaceName);
+    LuaTableVisitor v(L);
+    accept(ns, v);
+}
+
+} // namespace luabridge
diff --git a/Source/LuaBridge/LuaBridge.h b/Source/LuaBridge/LuaBridge.h
index ede78604..b64370e4 100644
--- a/Source/LuaBridge/LuaBridge.h
+++ b/Source/LuaBridge/LuaBridge.h
@@ -24,6 +24,7 @@
 #include "detail/Expected.h"
 #include "detail/FlagSet.h"
 #include "detail/FuncTraits.h"
+#include "detail/FunctionHints.h"
 #include "detail/Globals.h"
 #include "detail/Invoke.h"
 #include "detail/Iterator.h"
diff --git a/Source/LuaBridge/detail/CFunctions.h b/Source/LuaBridge/detail/CFunctions.h
index b8621190..0621d1f4 100644
--- a/Source/LuaBridge/detail/CFunctions.h
+++ b/Source/LuaBridge/detail/CFunctions.h
@@ -1897,6 +1897,12 @@ struct OverloadEntry
 
     int arity;           // -1 for variadic (lua_CFunction): always attempt
     TypeChecker checker; // nullptr for variadic: skip type pre-checking
+
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+    std::string returnType;                ///< C++ return type name (from detail::typeName)
+    std::vector<std::string> paramTypes;   ///< C++ parameter type names (excluding lua_State*)
+    std::vector<std::string> paramHints;   ///< Optional user-provided parameter names (from withHints)
+#endif
 };
 
 /**
diff --git a/Source/LuaBridge/detail/FunctionHints.h b/Source/LuaBridge/detail/FunctionHints.h
new file mode 100644
index 00000000..98c15510
--- /dev/null
+++ b/Source/LuaBridge/detail/FunctionHints.h
@@ -0,0 +1,176 @@
+// https://github.com/kunitoki/LuaBridge3
+// Copyright 2024, kunitoki
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "ClassInfo.h"
+#include "FuncTraits.h"
+
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace luabridge {
+
+//=================================================================================================
+/**
+ * @brief A wrapper that attaches Lua parameter name hints to a function or callable.
+ *
+ * Use luabridge::withHints() to create one. Transparently forwards all function trait queries
+ * to the wrapped function type, so it can be used anywhere a plain function is accepted.
+ *
+ * @code
+ * .addFunction("attack", luabridge::withHints(&Enemy::attack, "target", "damage"))
+ * @endcode
+ */
+template <class F>
+struct FunctionWithHints
+{
+    using func_type = F;
+
+    F func;
+    std::vector<std::string> hints; ///< Optional parameter name hints, one per Lua-visible parameter
+};
+
+/**
+ * @brief Attach Lua parameter name hints to a function for use with addFunction / addStaticFunction.
+ *
+ * @param func       The function, member function pointer, or lambda to wrap.
+ * @param paramNames Parameter names in the same order as the Lua-visible parameters.
+ *
+ * @returns A FunctionWithHints wrapper accepted by all addFunction / addStaticFunction overloads.
+ */
+template <class F, class... Names>
+[[nodiscard]] auto withHints(F&& func, Names&&... paramNames) -> FunctionWithHints<std::decay_t<F>>
+{
+    return { std::forward<F>(func), { std::string(std::forward<Names>(paramNames))... } };
+}
+
+namespace detail {
+
+//=================================================================================================
+// Trait: safely unwrap FunctionWithHints<F> to F, identity otherwise.
+// Unlike conditional_t<is_function_with_hints_v<T>, typename T::func_type, T>,
+// this trait never instantiates the ::func_type member for non-FunctionWithHints types.
+
+template <class T>
+struct unwrap_fn_type
+{
+    using type = T;
+};
+
+template <class F>
+struct unwrap_fn_type<FunctionWithHints<F>>
+{
+    using type = F;
+};
+
+template <class T>
+using unwrap_fn_type_t = typename unwrap_fn_type<T>::type;
+
+//=================================================================================================
+// Trait: detect FunctionWithHints<F>
+
+template <class T>
+struct is_function_with_hints : std::false_type
+{
+};
+
+template <class F>
+struct is_function_with_hints<FunctionWithHints<F>> : std::true_type
+{
+};
+
+template <class T>
+inline static constexpr bool is_function_with_hints_v = is_function_with_hints<T>::value;
+
+//=================================================================================================
+// Make function_traits<FunctionWithHints<F>> delegate to function_traits<F>
+// This makes function_result_t<>, function_arguments_t<>, function_arity_v<>, etc. all work
+// transparently through a FunctionWithHints wrapper.
+
+template <class F>
+struct function_traits<FunctionWithHints<F>> : function_traits<F>
+{
+};
+
+//=================================================================================================
+// Make is_callable<FunctionWithHints<F>> true when F is callable
+
+template <class F>
+struct is_callable<FunctionWithHints<F>>
+{
+    static constexpr bool value = is_callable_v<F>;
+};
+
+//=================================================================================================
+// Make const-member-pointer detection transparent through FunctionWithHints<F>
+
+template <class F>
+struct is_const_member_function_pointer<FunctionWithHints<F>>
+{
+    static constexpr bool value = is_const_member_function_pointer_v<F>;
+};
+
+//=================================================================================================
+// Helper: unwrap FunctionWithHints to its inner callable, or pass through unchanged.
+
+template <class F>
+[[nodiscard]] decltype(auto) get_underlying(F&& f) noexcept
+{
+    return std::forward<F>(f);
+}
+
+template <class F>
+[[nodiscard]] F&& get_underlying(FunctionWithHints<F>&& f) noexcept
+{
+    return std::move(f.func);
+}
+
+template <class F>
+[[nodiscard]] F& get_underlying(FunctionWithHints<F>& f) noexcept
+{
+    return f.func;
+}
+
+//=================================================================================================
+// Reflection helpers — only compiled when LUABRIDGE_ENABLE_REFLECT is defined.
+
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+
+/**
+ * @brief Build a vector of C++ type name strings from a tuple of types.
+ *
+ * lua_State* parameters are filtered out (they are auto-injected by LuaBridge, not
+ * visible from Lua).
+ */
+template <class Tuple>
+[[nodiscard]] std::vector<std::string> reflect_param_type_names()
+{
+    std::vector<std::string> result;
+
+    [&]<std::size_t... I>(std::index_sequence<I...>)
+    {
+        (
+            [&]
+            {
+                using ParamT = std::tuple_element_t<I, Tuple>;
+
+                constexpr bool isLuaState =
+                    std::is_pointer_v<ParamT> &&
+                    std::is_same_v<std::remove_const_t<std::remove_pointer_t<ParamT>>, lua_State>;
+
+                if constexpr (!isLuaState)
+                    result.push_back(std::string(typeName<std::remove_cvref_t<ParamT>>()));
+            }(),
+            ...);
+    }(std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+
+    return result;
+}
+
+#endif // LUABRIDGE_ENABLE_REFLECT
+
+} // namespace detail
+} // namespace luabridge
diff --git a/Source/LuaBridge/detail/LuaHelpers.h b/Source/LuaBridge/detail/LuaHelpers.h
index daab583b..099aed52 100644
--- a/Source/LuaBridge/detail/LuaHelpers.h
+++ b/Source/LuaBridge/detail/LuaHelpers.h
@@ -564,6 +564,57 @@ void* lua_newuserdata_aligned(lua_State* L, Args&&... args)
     return pointer;
 }
 
+/**
+ * @brief Portable wrapper for lua_resume that normalises calling convention differences
+ * across Lua 5.1/LuaJIT (no from, no nresults), 5.2-5.3 (from but no nresults), and 5.4+ (from + nresults).
+ *
+ * @param L      The coroutine thread to resume.
+ * @param from   The thread doing the resuming (may be nullptr on older Lua).
+ * @param nargs  Number of arguments on L's stack to pass to the resumed function.
+ * @param nresults Output: number of values on L's stack after resume (yielded or returned).
+ *                 For Lua 5.4+, filled directly by lua_resume. For older versions, computed via lua_gettop.
+ * @returns LUA_OK, LUA_YIELD, or an error code.
+ */
+inline int lua_resume_x(lua_State* L, lua_State* from, int nargs, int* nresults = nullptr)
+{
+#if LUABRIDGE_ON_LUAJIT || LUA_VERSION_NUM == 501
+    unused(from);
+    int status = lua_resume(L, nargs);
+    if (nresults)
+        *nresults = lua_gettop(L);
+    return status;
+#elif LUABRIDGE_ON_LUAU || LUABRIDGE_ON_RAVI || LUA_VERSION_NUM < 504
+    int status = lua_resume(L, from, nargs);
+    if (nresults)
+        *nresults = lua_gettop(L);
+    return status;
+#else
+    int nr = 0;
+    int status = lua_resume(L, from, nargs, &nr);
+    if (nresults)
+        *nresults = nr;
+    return status;
+#endif
+}
+
+/**
+ * @brief Returns true if the currently running C function can yield via lua_yieldk.
+ *
+ * Returns false on Lua 5.1, LuaJIT, and Luau where lua_yieldk is unavailable.
+ */
+inline bool lua_isyieldable_x(lua_State* L)
+{
+#if LUABRIDGE_ON_LUAJIT || LUA_VERSION_NUM == 501 || LUABRIDGE_ON_LUAU
+    unused(L);
+    return false;
+#elif LUA_VERSION_NUM < 503
+    unused(L);
+    return true; // lua_yieldk exists in 5.2; assume yieldable when reached
+#else
+    return lua_isyieldable(L) != 0;
+#endif
+}
+
 /**
  * @brief Safe error able to walk backwards for error reporting correctly.
  */
@@ -702,55 +753,4 @@ bool is_floating_point_representable_by(lua_State* L, int index)
     return isValid ? is_floating_point_representable_by<U>(value) : false;
 }
 
-/**
- * @brief Portable wrapper for lua_resume that normalises calling convention differences
- * across Lua 5.1/LuaJIT (no from, no nresults), 5.2-5.3 (from but no nresults), and 5.4+ (from + nresults).
- *
- * @param L      The coroutine thread to resume.
- * @param from   The thread doing the resuming (may be nullptr on older Lua).
- * @param nargs  Number of arguments on L's stack to pass to the resumed function.
- * @param nresults Output: number of values on L's stack after resume (yielded or returned).
- *                 For Lua 5.4+, filled directly by lua_resume. For older versions, computed via lua_gettop.
- * @returns LUA_OK, LUA_YIELD, or an error code.
- */
-inline int lua_resume_x(lua_State* L, lua_State* from, int nargs, int* nresults = nullptr)
-{
-#if LUABRIDGE_ON_LUAJIT || LUA_VERSION_NUM == 501
-    unused(from);
-    int status = lua_resume(L, nargs);
-    if (nresults)
-        *nresults = lua_gettop(L);
-    return status;
-#elif LUABRIDGE_ON_LUAU || LUABRIDGE_ON_RAVI || LUA_VERSION_NUM < 504
-    int status = lua_resume(L, from, nargs);
-    if (nresults)
-        *nresults = lua_gettop(L);
-    return status;
-#else
-    int nr = 0;
-    int status = lua_resume(L, from, nargs, &nr);
-    if (nresults)
-        *nresults = nr;
-    return status;
-#endif
-}
-
-/**
- * @brief Returns true if the currently running C function can yield via lua_yieldk.
- *
- * Returns false on Lua 5.1, LuaJIT, and Luau where lua_yieldk is unavailable.
- */
-inline bool lua_isyieldable_x(lua_State* L)
-{
-#if LUABRIDGE_ON_LUAJIT || LUA_VERSION_NUM == 501 || LUABRIDGE_ON_LUAU
-    unused(L);
-    return false;
-#elif LUA_VERSION_NUM < 503
-    unused(L);
-    return true; // lua_yieldk exists in 5.2; assume yieldable when reached
-#else
-    return lua_isyieldable(L) != 0;
-#endif
-}
-
 } // namespace luabridge
diff --git a/Source/LuaBridge/detail/Namespace.h b/Source/LuaBridge/detail/Namespace.h
index 3dc59f6b..e0271c66 100644
--- a/Source/LuaBridge/detail/Namespace.h
+++ b/Source/LuaBridge/detail/Namespace.h
@@ -745,11 +745,44 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                // Wrap in 1-entry OverloadSet so metadata is accessible at runtime.
                 ([&]
                 {
-                    detail::push_function(L, std::move(functions), name);
+                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                    detail::OverloadEntry entry;
+                    if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
+                    {
+                        using ArgsPack = detail::function_arguments_t<Functions>;
+                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
+                        entry.checker = &detail::overload_type_checker<ArgsPack>;
+                        entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                        entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        if constexpr (detail::is_function_with_hints_v<Functions>)
+                            entry.paramHints = functions.hints;
+                    }
+                    else
+                    {
+                        entry.arity = -1;
+                        entry.checker = nullptr;
+                    }
+                    overload_set->entries.push_back(std::move(entry));
+
+                    lua_createtable(L, 1, 0);
+                    detail::push_function(L, detail::get_underlying(std::move(functions)), name);
+                    lua_rawseti(L, -2, 1);
+                    lua_pushcclosure_x(L, &detail::try_overload_functions<false>, name, 2);
 
                 } (), ...);
+#else
+                ([&]
+                {
+                    detail::push_function(L, detail::get_underlying(std::move(functions)), name);
+
+                } (), ...);
+#endif
             }
             else
             {
@@ -770,6 +803,12 @@ class Namespace : public detail::Registrar
                         using ArgsPack = detail::function_arguments_t<Functions>;
                         entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                         entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                        entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                        entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        if constexpr (detail::is_function_with_hints_v<Functions>)
+                            entry.paramHints = functions.hints;
+#endif
                     }
                     overload_set->entries.push_back(entry);
 
@@ -782,7 +821,7 @@ class Namespace : public detail::Registrar
 
                 ([&]
                 {
-                    detail::push_function(L, std::move(functions), name);
+                    detail::push_function(L, detail::get_underlying(std::move(functions)), name);
                     lua_rawseti(L, -2, idx++);
 
                 } (), ...);
@@ -934,11 +973,56 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                // When reflection is enabled, wrap single functions in a 1-entry OverloadSet so
+                // metadata (return type, param types, hints) is uniformly accessible at runtime.
+                ([&]
+                {
+                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                    detail::OverloadEntry entry;
+                    if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
+                    {
+                        if constexpr (detail::is_proxy_member_function_v<T, Functions>)
+                        {
+                            using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
+                            entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
+                            entry.checker = &detail::overload_type_checker<ArgsPack>;
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        }
+                        else
+                        {
+                            using ArgsPack = detail::function_arguments_t<Functions>;
+                            entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
+                            entry.checker = &detail::overload_type_checker<ArgsPack>;
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        }
+                        if constexpr (detail::is_function_with_hints_v<Functions>)
+                            entry.paramHints = functions.hints;
+                    }
+                    else
+                    {
+                        entry.arity = -1;
+                        entry.checker = nullptr;
+                    }
+                    overload_set->entries.push_back(std::move(entry));
+
+                    lua_createtable(L, 1, 0);
+                    detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
+                    lua_rawseti(L, -2, 1);
+                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, name, 2);
+
+                } (), ...);
+#else
                 ([&]
                 {
-                    detail::push_member_function<T>(L, std::move(functions), name);
+                    detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
 
                 } (), ...);
+#endif
 
                 if constexpr (detail::const_functions_count<T, Functions...> == 1)
                 {
@@ -976,12 +1060,24 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                            if constexpr (detail::is_function_with_hints_v<Functions>)
+                                entry.paramHints = functions.hints;
+#endif
                         }
                         else
                         {
                             using ArgsPack = detail::function_arguments_t<Functions>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                            if constexpr (detail::is_function_with_hints_v<Functions>)
+                                entry.paramHints = functions.hints;
+#endif
                         }
                         overload_set_const->entries.push_back(entry);
 
@@ -999,7 +1095,7 @@ class Namespace : public detail::Registrar
                         if (!detail::is_const_function<T, Functions>)
                             return;
 
-                        detail::push_member_function<T>(L, std::move(functions), name);
+                        detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
                         lua_rawseti(L, -2, idx++);
 
                     } (), ...);
@@ -1033,12 +1129,24 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                            if constexpr (detail::is_function_with_hints_v<Functions>)
+                                entry.paramHints = functions.hints;
+#endif
                         }
                         else
                         {
                             using ArgsPack = detail::function_arguments_t<Functions>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                            if constexpr (detail::is_function_with_hints_v<Functions>)
+                                entry.paramHints = functions.hints;
+#endif
                         }
                         overload_set_nonconst->entries.push_back(entry);
 
@@ -1056,7 +1164,7 @@ class Namespace : public detail::Registrar
                         if (detail::is_const_function<T, Functions>)
                             return;
 
-                        detail::push_member_function<T>(L, std::move(functions), name);
+                        detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
                         lua_rawseti(L, -2, idx++);
 
                     } (), ...);
@@ -1158,11 +1266,35 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                // Wrap in 1-entry OverloadSet so constructor metadata is accessible at runtime.
+                ([&]
+                {
+                    using ArgsPack = detail::function_arguments_t<Functions>;
+
+                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                    detail::OverloadEntry entry;
+                    entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
+                    entry.checker = &detail::overload_type_checker<ArgsPack>;
+                    entry.returnType = std::string(detail::typeName<T>());
+                    entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                    overload_set->entries.push_back(std::move(entry));
+
+                    lua_createtable(L, 1, 0);
+                    lua_pushcclosure_x(L, &detail::constructor_placement_proxy<T, ArgsPack>, className, 0);
+                    lua_rawseti(L, -2, 1);
+                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, className, 2);
+
+                } (), ...);
+#else
                 ([&]
                 {
                     lua_pushcclosure_x(L, &detail::constructor_placement_proxy<T, detail::function_arguments_t<Functions>>, className, 0);
 
                 } (), ...);
+#endif
             }
             else
             {
@@ -1176,6 +1308,10 @@ class Namespace : public detail::Registrar
                     detail::OverloadEntry entry;
                     entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                     entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                    entry.returnType = std::string(detail::typeName<T>());
+                    entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+#endif
                     overload_set->entries.push_back(entry);
 
                 } (), ...);
@@ -1222,11 +1358,36 @@ class Namespace : public detail::Registrar
             {
                 ([&]
                 {
-                    using F = detail::constructor_forwarder<T, Functions>;
+                    using InnerF = detail::unwrap_fn_type_t<Functions>;
+                    using F = detail::constructor_forwarder<T, InnerF>;
 
-                    lua_newuserdata_aligned<F>(L, F(std::move(functions))); // Stack: co, cl, st, upvalue
-                    lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1); // Stack: co, cl, st, function
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                    // Wrap in 1-entry OverloadSet so constructor metadata is accessible at runtime.
+                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                    {
+                        // skip void* first arg (placement new destination, not a Lua argument)
+                        using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<InnerF>>;
+                        detail::OverloadEntry entry;
+                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<InnerF, lua_State*>) - 1;
+                        entry.checker = &detail::overload_type_checker<ArgsPack>;
+                        entry.returnType = std::string(detail::typeName<T>());
+                        entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        if constexpr (detail::is_function_with_hints_v<Functions>)
+                            entry.paramHints = functions.hints;
+                        overload_set->entries.push_back(std::move(entry));
+                    }
 
+                    lua_createtable(L, 1, 0);
+                    lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions))));
+                    lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1);
+                    lua_rawseti(L, -2, 1);
+                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, className, 2);
+#else
+                    lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions)))); // Stack: co, cl, st, upvalue
+                    lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1); // Stack: co, cl, st, function
+#endif
                 } (), ...);
             }
             else
@@ -1237,8 +1398,10 @@ class Namespace : public detail::Registrar
 
                 ([&]
                 {
+                    using InnerF = detail::unwrap_fn_type_t<Functions>;
+
                     detail::OverloadEntry entry;
-                    if constexpr (detail::is_any_cfunction_pointer_v<Functions>)
+                    if constexpr (detail::is_any_cfunction_pointer_v<InnerF>)
                     {
                         entry.arity = -1;
                         entry.checker = nullptr;
@@ -1246,9 +1409,15 @@ class Namespace : public detail::Registrar
                     else
                     {
                         // skip void* first arg (placement new destination, not a Lua argument)
-                        using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
-                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>) - 1;
+                        using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<InnerF>>;
+                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<InnerF, lua_State*>) - 1;
                         entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                        entry.returnType = std::string(detail::typeName<T>());
+                        entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                        if constexpr (detail::is_function_with_hints_v<Functions>)
+                            entry.paramHints = functions.hints;
+#endif
                     }
                     overload_set->entries.push_back(entry);
 
@@ -1261,9 +1430,10 @@ class Namespace : public detail::Registrar
 
                 ([&]
                 {
-                    using F = detail::constructor_forwarder<T, Functions>;
+                    using InnerF = detail::unwrap_fn_type_t<Functions>;
+                    using F = detail::constructor_forwarder<T, InnerF>;
 
-                    lua_newuserdata_aligned<F>(L, F(std::move(functions)));
+                    lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions))));
                     lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1);
                     lua_rawseti(L, -2, idx++);
 
@@ -1922,11 +2092,44 @@ class Namespace : public detail::Registrar
 
         if constexpr (sizeof...(Functions) == 1)
         {
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+            // Wrap in 1-entry OverloadSet so metadata is accessible at runtime.
             ([&]
             {
-                detail::push_function(L, std::move(functions), name);
+                auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                detail::OverloadEntry entry;
+                if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
+                {
+                    using ArgsPack = detail::function_arguments_t<Functions>;
+                    entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
+                    entry.checker = &detail::overload_type_checker<ArgsPack>;
+                    entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                    entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                    if constexpr (detail::is_function_with_hints_v<Functions>)
+                        entry.paramHints = functions.hints;
+                }
+                else
+                {
+                    entry.arity = -1;
+                    entry.checker = nullptr;
+                }
+                overload_set->entries.push_back(std::move(entry));
+
+                lua_createtable(L, 1, 0);
+                detail::push_function(L, detail::get_underlying(std::move(functions)), name);
+                lua_rawseti(L, -2, 1);
+                lua_pushcclosure_x(L, &detail::try_overload_functions<false>, name, 2);
 
             } (), ...);
+#else
+            ([&]
+            {
+                detail::push_function(L, detail::get_underlying(std::move(functions)), name);
+
+            } (), ...);
+#endif
         }
         else
         {
@@ -1947,6 +2150,12 @@ class Namespace : public detail::Registrar
                     using ArgsPack = detail::function_arguments_t<Functions>;
                     entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                     entry.checker = &detail::overload_type_checker<ArgsPack>;
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+                    entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                    entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
+                    if constexpr (detail::is_function_with_hints_v<Functions>)
+                        entry.paramHints = functions.hints;
+#endif
                 }
                 overload_set->entries.push_back(entry);
 
@@ -1959,7 +2168,7 @@ class Namespace : public detail::Registrar
 
             ([&]
             {
-                detail::push_function(L, std::move(functions), name);
+                detail::push_function(L, detail::get_underlying(std::move(functions)), name);
                 lua_rawseti(L, -2, idx++);
 
             } (), ...);
diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index 414d3a9a..42fa651e 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -33,6 +33,7 @@ set (LUABRIDGE_TEST_SOURCE_FILES
   Source/ClassTests.cpp
   Source/CoroutineTests.cpp
   Source/DumpTests.cpp
+  Source/InspectTests.cpp
   Source/EnumTests.cpp
   Source/ExceptionTests.cpp
   Source/FlagSetTests.cpp
@@ -285,6 +286,7 @@ macro (add_test_app LUABRIDGE_TEST_NAME LUA_VERSION LUABRIDGE_TEST_LUA_LIBRARY_F
 
     target_compile_definitions (${LUABRIDGE_TESTLIB_NAME} PRIVATE
       LUABRIDGE_TEST_SHARED_EXPORT=1
+      LUABRIDGE_ENABLE_REFLECT=1
       ${LUABRIDGE_DEFINES})
 
     target_include_directories (${LUABRIDGE_TESTLIB_NAME} PRIVATE
@@ -386,10 +388,13 @@ macro (add_test_app LUABRIDGE_TEST_NAME LUA_VERSION LUABRIDGE_TEST_LUA_LIBRARY_F
       set (LUABRIDGE_TEST_SHARED_LIBRARY "lib${LUABRIDGE_TESTLIB_NAME}.so")
     endif ()
     target_compile_definitions (${LUABRIDGE_TEST_NAME} PRIVATE
+      LUABRIDGE_ENABLE_REFLECT=1
       LUABRIDGE_TEST_SHARED_LIBRARY="${LUABRIDGE_TEST_SHARED_LIBRARY}"
       LUABRIDGE_TEST_SHARED_EXPORT=0)
   endif ()
 
+  target_compile_definitions (${LUABRIDGE_TEST_NAME} PRIVATE LUABRIDGE_ENABLE_REFLECT=1)
+
   if (NOT ${LUABRIDGE_EXCEPTIONS})
     target_compile_definitions (${LUABRIDGE_TEST_NAME} PRIVATE LUA_USE_LONGJMP=1)
     if (APPLE)
diff --git a/Tests/Source/InspectTests.cpp b/Tests/Source/InspectTests.cpp
new file mode 100644
index 00000000..7d4ac746
--- /dev/null
+++ b/Tests/Source/InspectTests.cpp
@@ -0,0 +1,565 @@
+// https://github.com/kunitoki/LuaBridge3
+// Copyright 2024, kunitoki
+// SPDX-License-Identifier: MIT
+
+#include "TestBase.h"
+
+#include "LuaBridge/LuaBridge.h"
+
+#include <algorithm>
+#include <sstream>
+
+struct InspectTests : TestBase
+{
+};
+
+//=================================================================================================
+// Helpers
+
+namespace {
+
+const luabridge::MemberInfo* findMember(const luabridge::ClassInspectInfo& cls, const std::string& name)
+{
+    for (const auto& m : cls.members)
+        if (m.name == name) return &m;
+    return nullptr;
+}
+
+const luabridge::MemberInfo* findFreeMember(const luabridge::NamespaceInspectInfo& ns, const std::string& name)
+{
+    for (const auto& m : ns.freeMembers)
+        if (m.name == name) return &m;
+    return nullptr;
+}
+
+const luabridge::ClassInspectInfo* findClass(const luabridge::NamespaceInspectInfo& ns, const std::string& name)
+{
+    for (const auto& c : ns.classes)
+        if (c.name == name) return &c;
+    return nullptr;
+}
+
+const luabridge::NamespaceInspectInfo* findSubNamespace(const luabridge::NamespaceInspectInfo& ns, const std::string& name)
+{
+    for (const auto& s : ns.subNamespaces)
+        if (s.name == name) return &s;
+    return nullptr;
+}
+
+bool hasBase(const luabridge::ClassInspectInfo& cls, const std::string& name)
+{
+    return std::find(cls.baseClasses.begin(), cls.baseClasses.end(), name) != cls.baseClasses.end();
+}
+
+} // anonymous namespace
+
+//=================================================================================================
+// inspect<T>() — single class tests
+
+TEST_F(InspectTests, InspectUnregisteredClass)
+{
+    struct Unregistered {};
+    auto info = luabridge::inspect<Unregistered>(L);
+    EXPECT_TRUE(info.name.empty());
+    EXPECT_TRUE(info.members.empty());
+    EXPECT_TRUE(info.baseClasses.empty());
+}
+
+TEST_F(InspectTests, InspectSimpleClass)
+{
+    struct Foo
+    {
+        int x = 0;
+        int getX() const { return x; }
+        void setX(int v) { x = v; }
+        void doSomething() {}
+        static int staticFunc() { return 42; }
+    };
+
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Foo>("Foo")
+            .addConstructor<void()>()
+            .addProperty("x", &Foo::getX, &Foo::setX)
+            .addFunction("doSomething", &Foo::doSomething)
+            .addStaticFunction("staticFunc", &Foo::staticFunc)
+        .endClass();
+
+    auto info = luabridge::inspect<Foo>(L);
+    EXPECT_EQ("Foo", info.name);
+
+    auto* prop = findMember(info, "x");
+    ASSERT_NE(nullptr, prop);
+    EXPECT_EQ(luabridge::MemberKind::Property, prop->kind);
+
+    auto* method = findMember(info, "doSomething");
+    ASSERT_NE(nullptr, method);
+    EXPECT_EQ(luabridge::MemberKind::Method, method->kind);
+    EXPECT_EQ(1u, method->overloads.size());
+
+    auto* staticFn = findMember(info, "staticFunc");
+    ASSERT_NE(nullptr, staticFn);
+    EXPECT_EQ(luabridge::MemberKind::StaticMethod, staticFn->kind);
+
+    auto* ctor = findMember(info, "__call");
+    ASSERT_NE(nullptr, ctor);
+    EXPECT_EQ(luabridge::MemberKind::Constructor, ctor->kind);
+}
+
+TEST_F(InspectTests, InspectReadOnlyProperty)
+{
+    struct Bar { int getValue() const { return 1; } };
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Bar>("Bar")
+            .addProperty("value", &Bar::getValue)
+        .endClass();
+
+    auto info = luabridge::inspect<Bar>(L);
+    auto* prop = findMember(info, "value");
+    ASSERT_NE(nullptr, prop);
+    EXPECT_EQ(luabridge::MemberKind::ReadOnlyProperty, prop->kind);
+}
+
+TEST_F(InspectTests, InspectOverloadedMethod)
+{
+    struct Baz {};
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Baz>("Baz")
+            .addFunction("method",
+                [](Baz&, int) {},
+                [](Baz&, float) {})
+        .endClass();
+
+    auto info = luabridge::inspect<Baz>(L);
+    auto* method = findMember(info, "method");
+    ASSERT_NE(nullptr, method);
+    EXPECT_EQ(luabridge::MemberKind::Method, method->kind);
+    EXPECT_EQ(2u, method->overloads.size());
+}
+
+TEST_F(InspectTests, InspectDerivedClass)
+{
+    struct Base { int baseMethod() const { return 1; } };
+    struct Derived : Base { int derivedMethod() const { return 2; } };
+
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Base>("Base")
+            .addFunction("baseMethod", &Base::baseMethod)
+        .endClass()
+        .deriveClass<Derived, Base>("Derived")
+            .addFunction("derivedMethod", &Derived::derivedMethod)
+        .endClass();
+
+    auto info = luabridge::inspect<Derived>(L);
+    EXPECT_EQ("Derived", info.name);
+    EXPECT_FALSE(info.baseClasses.empty());
+    EXPECT_TRUE(hasBase(info, "Base"));
+}
+
+TEST_F(InspectTests, InspectMetamethods)
+{
+    struct Vec
+    {
+        Vec operator+(const Vec& /*rhs*/) const { return {}; }
+    };
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Vec>("Vec")
+            .addFunction("__add", &Vec::operator+)
+        .endClass();
+
+    auto info = luabridge::inspect<Vec>(L);
+    auto* add = findMember(info, "__add");
+    ASSERT_NE(nullptr, add);
+    EXPECT_EQ(luabridge::MemberKind::Metamethod, add->kind);
+}
+
+TEST_F(InspectTests, InspectStaticReadOnlyProperty)
+{
+    struct WithStatic {};
+    static int sVal = 42;
+    luabridge::getGlobalNamespace(L)
+        .beginClass<WithStatic>("WithStatic")
+            .addStaticProperty("ROProp", +[]() { return sVal; })
+            .addStaticProperty("RWProp", +[]() { return sVal; }, +[](int v) { sVal = v; })
+        .endClass();
+
+    auto info = luabridge::inspect<WithStatic>(L);
+
+    auto* ro = findMember(info, "ROProp");
+    ASSERT_NE(nullptr, ro);
+    EXPECT_EQ(luabridge::MemberKind::StaticReadOnlyProperty, ro->kind);
+
+    auto* rw = findMember(info, "RWProp");
+    ASSERT_NE(nullptr, rw);
+    EXPECT_EQ(luabridge::MemberKind::StaticProperty, rw->kind);
+}
+
+//=================================================================================================
+// inspectNamespace() tests
+
+TEST_F(InspectTests, InspectNamespace)
+{
+    struct Widget { void draw() {} };
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("UI")
+            .beginClass<Widget>("Widget")
+                .addFunction("draw", &Widget::draw)
+            .endClass()
+            .addFunction("ping", +[]() -> int { return 1; })
+        .endNamespace();
+
+    auto ns = luabridge::inspectNamespace(L, "UI");
+    EXPECT_EQ("UI", ns.name);
+
+    auto* w = findClass(ns, "Widget");
+    ASSERT_NE(nullptr, w);
+    EXPECT_EQ("Widget", w->name);
+
+    auto* ping = findFreeMember(ns, "ping");
+    ASSERT_NE(nullptr, ping);
+    EXPECT_EQ(luabridge::MemberKind::Method, ping->kind);
+}
+
+TEST_F(InspectTests, InspectSubNamespace)
+{
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("Outer")
+            .beginNamespace("Inner")
+                .addFunction("innerFunc", +[]() {})
+            .endNamespace()
+        .endNamespace();
+
+    auto ns = luabridge::inspectNamespace(L, "Outer");
+    EXPECT_EQ("Outer", ns.name);
+
+    auto* inner = findSubNamespace(ns, "Inner");
+    ASSERT_NE(nullptr, inner);
+    EXPECT_EQ("Inner", inner->name);
+
+    auto* fn = findFreeMember(*inner, "innerFunc");
+    ASSERT_NE(nullptr, fn);
+}
+
+TEST_F(InspectTests, InspectEmptyNamespace)
+{
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("Empty")
+        .endNamespace();
+
+    auto ns = luabridge::inspectNamespace(L, "Empty");
+    EXPECT_EQ("Empty", ns.name);
+    EXPECT_TRUE(ns.classes.empty());
+    EXPECT_TRUE(ns.freeMembers.empty());
+    EXPECT_TRUE(ns.subNamespaces.empty());
+}
+
+TEST_F(InspectTests, InspectNonexistentNamespace)
+{
+    auto ns = luabridge::inspectNamespace(L, "DoesNotExist");
+    EXPECT_TRUE(ns.name.empty());
+}
+
+TEST_F(InspectTests, InspectDottedNamespacePath)
+{
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("A")
+            .beginNamespace("B")
+                .addFunction("deep", +[]() {})
+            .endNamespace()
+        .endNamespace();
+
+    auto ns = luabridge::inspectNamespace(L, "A.B");
+    EXPECT_EQ("B", ns.name);
+    EXPECT_NE(nullptr, findFreeMember(ns, "deep"));
+}
+
+TEST_F(InspectTests, InspectNamespaceProperty)
+{
+    static int nsVal = 0;
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("NsProp")
+            .addProperty("roProp", +[]() { return nsVal; })
+            .addProperty("rwProp", +[]() { return nsVal; }, +[](int v) { nsVal = v; })
+        .endNamespace();
+
+    auto ns = luabridge::inspectNamespace(L, "NsProp");
+    auto* ro = findFreeMember(ns, "roProp");
+    ASSERT_NE(nullptr, ro);
+    EXPECT_EQ(luabridge::MemberKind::ReadOnlyProperty, ro->kind);
+
+    auto* rw = findFreeMember(ns, "rwProp");
+    ASSERT_NE(nullptr, rw);
+    EXPECT_EQ(luabridge::MemberKind::Property, rw->kind);
+}
+
+//=================================================================================================
+// Visitor tests
+
+TEST_F(InspectTests, ConsoleVisitorProducesOutput)
+{
+    struct Cls {};
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("ConsTest")
+            .beginClass<Cls>("Cls")
+                .addConstructor<void()>()
+            .endClass()
+        .endNamespace();
+
+    std::stringstream ss;
+    luabridge::inspectPrint(L, "ConsTest", ss);
+    EXPECT_FALSE(ss.str().empty());
+    EXPECT_NE(std::string::npos, ss.str().find("ConsTest"));
+    EXPECT_NE(std::string::npos, ss.str().find("Cls"));
+}
+
+TEST_F(InspectTests, LuaTableVisitorProducesTable)
+{
+    struct Cls { void m() {} };
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("TblTest")
+            .beginClass<Cls>("Cls")
+                .addFunction("m", &Cls::m)
+            .endClass()
+        .endNamespace();
+
+    int topBefore = lua_gettop(L);
+    luabridge::inspectToLua(L, "TblTest");
+
+    ASSERT_EQ(topBefore + 1, lua_gettop(L));
+    ASSERT_TRUE(lua_istable(L, -1));
+
+    lua_getfield(L, -1, "name");
+    EXPECT_STREQ("TblTest", lua_tostring(L, -1));
+    lua_pop(L, 1);
+
+    lua_getfield(L, -1, "classes");
+    EXPECT_TRUE(lua_istable(L, -1));
+    EXPECT_EQ(1, (int)lua_rawlen(L, -1));
+    lua_pop(L, 1);
+
+    lua_pop(L, 1); // pop result table
+    EXPECT_EQ(topBefore, lua_gettop(L));
+}
+
+TEST_F(InspectTests, LuaLSVisitorProducesAnnotations)
+{
+    struct Cls { int getValue() const { return 0; } };
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("LuaLS")
+            .beginClass<Cls>("Cls")
+                .addProperty("value", &Cls::getValue)
+            .endClass()
+        .endNamespace();
+
+    auto ns = luabridge::inspectNamespace(L, "LuaLS");
+    std::stringstream ss;
+    luabridge::LuaLSVisitor v(ss);
+    luabridge::accept(ns, v);
+
+    const auto result = ss.str();
+    EXPECT_FALSE(result.empty());
+    EXPECT_NE(std::string::npos, result.find("@class"));
+    EXPECT_NE(std::string::npos, result.find("Cls"));
+}
+
+TEST_F(InspectTests, LuaProxyVisitorProducesStubs)
+{
+    struct Cls { void method() {} };
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("Proxy")
+            .beginClass<Cls>("Cls")
+                .addConstructor<void()>()
+                .addFunction("method", &Cls::method)
+            .endClass()
+        .endNamespace();
+
+    auto ns = luabridge::inspectNamespace(L, "Proxy");
+    std::stringstream ss;
+    luabridge::LuaProxyVisitor v(ss);
+    luabridge::accept(ns, v);
+
+    const auto result = ss.str();
+    EXPECT_FALSE(result.empty());
+    EXPECT_NE(std::string::npos, result.find("Cls"));
+    EXPECT_NE(std::string::npos, result.find("method"));
+}
+
+TEST_F(InspectTests, JsonVisitorProducesJson)
+{
+    struct Cls {};
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("Json")
+            .beginClass<Cls>("Cls").endClass()
+        .endNamespace();
+
+    auto ns = luabridge::inspectNamespace(L, "Json");
+    std::stringstream ss;
+    luabridge::JsonVisitor v(ss);
+    luabridge::accept(ns, v);
+
+    const auto result = ss.str();
+    EXPECT_FALSE(result.empty());
+    EXPECT_NE(std::string::npos, result.find("\"name\""));
+    EXPECT_NE(std::string::npos, result.find("Json"));
+}
+
+//=================================================================================================
+// inspect<T>() stack balance test
+
+TEST_F(InspectTests, InspectDoesNotLeakStack)
+{
+    struct Foo { void m() {} };
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Foo>("Foo")
+            .addFunction("m", &Foo::m)
+        .endClass();
+
+    int top = lua_gettop(L);
+    auto info = luabridge::inspect<Foo>(L);
+    EXPECT_EQ(top, lua_gettop(L));
+    EXPECT_EQ("Foo", info.name);
+}
+
+TEST_F(InspectTests, InspectNamespaceDoesNotLeakStack)
+{
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("StackTest")
+            .addFunction("f", +[]() {})
+        .endNamespace();
+
+    int top = lua_gettop(L);
+    auto ns = luabridge::inspectNamespace(L, "StackTest");
+    EXPECT_EQ(top, lua_gettop(L));
+    EXPECT_EQ("StackTest", ns.name);
+}
+
+//=================================================================================================
+// inspectAccept() helper
+
+TEST_F(InspectTests, InspectAcceptDrivesVisitor)
+{
+    struct Cls { void m() {} };
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("AccTest")
+            .beginClass<Cls>("Cls")
+                .addFunction("m", &Cls::m)
+            .endClass()
+        .endNamespace();
+
+    struct CountingVisitor : luabridge::InspectVisitor
+    {
+        int classCount = 0;
+        int memberCount = 0;
+        void beginClass(const luabridge::ClassInspectInfo&) override { ++classCount; }
+        void visitMember(const luabridge::ClassInspectInfo&, const luabridge::MemberInfo&) override { ++memberCount; }
+    };
+
+    CountingVisitor cv;
+    luabridge::inspectAccept(L, "AccTest", cv);
+    EXPECT_EQ(1, cv.classCount);
+    EXPECT_GE(cv.memberCount, 1);
+}
+
+//=================================================================================================
+// withHints() API test (tests FunctionWithHints detection)
+
+TEST_F(InspectTests, WithHintsIsAcceptedByAddFunction)
+{
+    struct Actor { void attack(float /*damage*/) {} };
+
+    // This test verifies that withHints compiles and the function is registered correctly.
+    EXPECT_NO_THROW(
+        luabridge::getGlobalNamespace(L)
+            .beginClass<Actor>("Actor")
+                .addFunction("attack", luabridge::withHints(&Actor::attack, "damage"))
+            .endClass()
+    );
+
+    // Verify the function is callable from Lua
+    auto info = luabridge::inspect<Actor>(L);
+    auto* m = findMember(info, "attack");
+    ASSERT_NE(nullptr, m);
+    EXPECT_EQ(luabridge::MemberKind::Method, m->kind);
+}
+
+TEST_F(InspectTests, WithHintsOverloadsCompile)
+{
+    struct Shooter {};
+
+    EXPECT_NO_THROW(
+        luabridge::getGlobalNamespace(L)
+            .beginClass<Shooter>("Shooter")
+                .addFunction("fire",
+                    luabridge::withHints([](Shooter&, int /*count*/) {}, "count"),
+                    luabridge::withHints([](Shooter&, float /*angle*/, int /*count*/) {}, "angle", "count"))
+            .endClass()
+    );
+
+    auto info = luabridge::inspect<Shooter>(L);
+    auto* m = findMember(info, "fire");
+    ASSERT_NE(nullptr, m);
+    EXPECT_EQ(2u, m->overloads.size());
+}
+
+#if defined(LUABRIDGE_ENABLE_REFLECT)
+
+TEST_F(InspectTests, ReflectTypeInfoPopulated)
+{
+    struct Enemy { void takeDamage(float /*amount*/, int /*count*/) {} };
+
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Enemy>("Enemy")
+            .addFunction("takeDamage", luabridge::withHints(&Enemy::takeDamage, "amount", "count"))
+        .endClass();
+
+    auto info = luabridge::inspect<Enemy>(L);
+    auto* m = findMember(info, "takeDamage");
+    ASSERT_NE(nullptr, m);
+    ASSERT_EQ(1u, m->overloads.size());
+
+    const auto& ov = m->overloads[0];
+    ASSERT_EQ(2u, ov.params.size());
+
+    // Type names should be non-empty when LUABRIDGE_ENABLE_REFLECT is active
+    EXPECT_FALSE(ov.params[0].typeName.empty());
+    EXPECT_FALSE(ov.params[1].typeName.empty());
+
+    // Hints should be populated from withHints
+    EXPECT_EQ("amount", ov.params[0].hint);
+    EXPECT_EQ("count", ov.params[1].hint);
+}
+
+TEST_F(InspectTests, ReflectConstructorTypeInfo)
+{
+    struct Widget {};
+
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Widget>("Widget")
+            .addConstructor<void(int, float)>()
+        .endClass();
+
+    auto info = luabridge::inspect<Widget>(L);
+    auto* ctor = findMember(info, "__call");
+    ASSERT_NE(nullptr, ctor);
+    ASSERT_EQ(1u, ctor->overloads.size());
+
+    EXPECT_EQ(2u, ctor->overloads[0].params.size());
+}
+
+TEST_F(InspectTests, ReflectFreeFunction)
+{
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("ReflectNS")
+            .addFunction("add",
+                luabridge::withHints(+[](int a, int b) -> int { return a + b; }, "a", "b"))
+        .endNamespace();
+
+    auto ns = luabridge::inspectNamespace(L, "ReflectNS");
+    auto* fn = findFreeMember(ns, "add");
+    ASSERT_NE(nullptr, fn);
+    ASSERT_EQ(1u, fn->overloads.size());
+    ASSERT_EQ(2u, fn->overloads[0].params.size());
+    EXPECT_EQ("a", fn->overloads[0].params[0].hint);
+    EXPECT_EQ("b", fn->overloads[0].params[1].hint);
+}
+
+#endif // LUABRIDGE_ENABLE_REFLECT
diff --git a/amalgamate.py b/amalgamate.py
index e12f99b5..1a23a815 100644
--- a/amalgamate.py
+++ b/amalgamate.py
@@ -196,8 +196,14 @@ def WriteAlgamationFiles(self):
 			headerAmalgamation.write(f"// clang-format off\n\n")
 			headerAmalgamation.write(f"#pragma once\n\n")
 
+			guarded_includes = set(["coroutine", "span"])
 			for header in sorted(list(self.systemHeaders)):
-				headerAmalgamation.write(f"#include <{header}>\n")
+				if header in guarded_includes:
+					headerAmalgamation.write(f"#if defined(__has_include) && __has_include(<{header}>)\n")
+					headerAmalgamation.write(f"#include <{header}>\n")
+					headerAmalgamation.write(f"#endif\n\n")
+				else:
+					headerAmalgamation.write(f"#include <{header}>\n")
 			headerAmalgamation.write("\n")
 
 			self.AmalgamateQueue(self.headerQueue, headerAmalgamation)
diff --git a/justfile b/justfile
index 9a84bf48..ae502c91 100644
--- a/justfile
+++ b/justfile
@@ -22,7 +22,8 @@ plot:
     uv run --with-requirements Benchmarks/requirements.txt Benchmarks/plot_benchmarks.py --input Build/*.json --output Images/benchmarks.png
 
 clean:
-    rm -rf Build
+    -rm -rf Build/
+    rm -rf Build/
 
 amalgamate:
     uv run amalgamate.py

From a2b0a3245ca5b4741d18193b2dc470e73421faf9 Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Tue, 7 Apr 2026 16:41:00 +0200
Subject: [PATCH 02/14] Fix inspection

---
 .github/workflows/build_asan.yml        |   4 +
 .github/workflows/build_linux.yml       |   4 +
 .github/workflows/build_macos.yml       |   4 +
 .github/workflows/build_tsan.yml_       |   4 +
 .github/workflows/build_ubsan.yml       |   4 +
 .github/workflows/build_windows.yml     |   4 +
 .github/workflows/coverage.yml          |   4 +
 Distribution/LuaBridge/LuaBridge.h      | 496 +++++++++++++++---------
 Source/LuaBridge/Inspect.h              | 110 +++---
 Source/LuaBridge/detail/CFunctions.h    | 218 +++++++++--
 Source/LuaBridge/detail/FunctionHints.h |  38 +-
 Source/LuaBridge/detail/Namespace.h     | 175 ++++-----
 Tests/CMakeLists.txt                    | 164 ++++----
 Tests/Source/InspectTests.cpp           |  33 +-
 14 files changed, 774 insertions(+), 488 deletions(-)

diff --git a/.github/workflows/build_asan.yml b/.github/workflows/build_asan.yml
index 82af7a4e..24f7db7e 100644
--- a/.github/workflows/build_asan.yml
+++ b/.github/workflows/build_asan.yml
@@ -53,8 +53,10 @@ jobs:
       run: |
         cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
           LuaBridgeTests${{ matrix.lua.suffix }} \
+          LuaBridgeTests${{ matrix.lua.suffix }}Reflect \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaC \
           LuaBridgeTests${{ matrix.lua.suffix }}Noexcept \
+          LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
 
     - name: Test Lua ${{ matrix.lua.version }}
@@ -63,6 +65,8 @@ jobs:
         ASAN_OPTIONS: detect_leaks=0:detect_odr_violation=0
       run: |
         ./LuaBridgeTests${{ matrix.lua.suffix }}
+        ./LuaBridgeTests${{ matrix.lua.suffix }}Reflect
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaC
         ./LuaBridgeTests${{ matrix.lua.suffix }}Noexcept
+        ./LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
diff --git a/.github/workflows/build_linux.yml b/.github/workflows/build_linux.yml
index 06430c9c..75b2aeec 100644
--- a/.github/workflows/build_linux.yml
+++ b/.github/workflows/build_linux.yml
@@ -53,16 +53,20 @@ jobs:
       run: |
         cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
           LuaBridgeTests${{ matrix.lua.suffix }} \
+          LuaBridgeTests${{ matrix.lua.suffix }}Reflect \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaC \
           LuaBridgeTests${{ matrix.lua.suffix }}Noexcept \
+          LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
 
     - name: Test Lua ${{ matrix.lua.version }}
       working-directory: ${{runner.workspace}}/build/Tests
       run: |
         ./LuaBridgeTests${{ matrix.lua.suffix }}
+        ./LuaBridgeTests${{ matrix.lua.suffix }}Reflect
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaC
         ./LuaBridgeTests${{ matrix.lua.suffix }}Noexcept
+        ./LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
 
   luajit:
diff --git a/.github/workflows/build_macos.yml b/.github/workflows/build_macos.yml
index 0ff61011..9d0962f4 100644
--- a/.github/workflows/build_macos.yml
+++ b/.github/workflows/build_macos.yml
@@ -50,16 +50,20 @@ jobs:
       run: |
         cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
           LuaBridgeTests${{ matrix.lua.suffix }} \
+          LuaBridgeTests${{ matrix.lua.suffix }}Reflect \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaC \
           LuaBridgeTests${{ matrix.lua.suffix }}Noexcept \
+          LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
 
     - name: Test Lua ${{ matrix.lua.version }}
       working-directory: ${{runner.workspace}}/build/Tests
       run: |
         ./LuaBridgeTests${{ matrix.lua.suffix }}
+        ./LuaBridgeTests${{ matrix.lua.suffix }}Reflect
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaC
         ./LuaBridgeTests${{ matrix.lua.suffix }}Noexcept
+        ./LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
 
   luajit:
diff --git a/.github/workflows/build_tsan.yml_ b/.github/workflows/build_tsan.yml_
index f0dbed88..549e64e2 100644
--- a/.github/workflows/build_tsan.yml_
+++ b/.github/workflows/build_tsan.yml_
@@ -53,8 +53,10 @@ jobs:
       run: |
         cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
           LuaBridgeTests${{ matrix.lua.suffix }} \
+          LuaBridgeTests${{ matrix.lua.suffix }}Reflect \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaC \
           LuaBridgeTests${{ matrix.lua.suffix }}Noexcept \
+          LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
 
     - name: Test Lua ${{ matrix.lua.version }}
@@ -63,6 +65,8 @@ jobs:
         TSAN_OPTIONS: halt_on_error=1:print_stacktrace=1
       run: |
         ./LuaBridgeTests${{ matrix.lua.suffix }}
+        ./LuaBridgeTests${{ matrix.lua.suffix }}Reflect
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaC
         ./LuaBridgeTests${{ matrix.lua.suffix }}Noexcept
+        ./LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
diff --git a/.github/workflows/build_ubsan.yml b/.github/workflows/build_ubsan.yml
index 88691cf4..e826304e 100644
--- a/.github/workflows/build_ubsan.yml
+++ b/.github/workflows/build_ubsan.yml
@@ -53,8 +53,10 @@ jobs:
       run: |
         cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
           LuaBridgeTests${{ matrix.lua.suffix }} \
+          LuaBridgeTests${{ matrix.lua.suffix }}Reflect \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaC \
           LuaBridgeTests${{ matrix.lua.suffix }}Noexcept \
+          LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
 
     - name: Test Lua ${{ matrix.lua.version }}
@@ -63,6 +65,8 @@ jobs:
         UBSAN_OPTIONS: halt_on_error=1:print_stacktrace=1
       run: |
         ./LuaBridgeTests${{ matrix.lua.suffix }}
+        ./LuaBridgeTests${{ matrix.lua.suffix }}Reflect
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaC
         ./LuaBridgeTests${{ matrix.lua.suffix }}Noexcept
+        ./LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
diff --git a/.github/workflows/build_windows.yml b/.github/workflows/build_windows.yml
index a67bb15b..f7f3762e 100644
--- a/.github/workflows/build_windows.yml
+++ b/.github/workflows/build_windows.yml
@@ -52,8 +52,10 @@ jobs:
       run: |
         cmake --build . --config $BUILD_TYPE --parallel 4 --target \
           LuaBridgeTests${{ matrix.lua.suffix }} \
+          LuaBridgeTests${{ matrix.lua.suffix }}Reflect \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaC \
           LuaBridgeTests${{ matrix.lua.suffix }}Noexcept \
+          LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
 
     - name: Test Lua ${{ matrix.lua.version }}
@@ -61,8 +63,10 @@ jobs:
       shell: bash
       run: |
         ./LuaBridgeTests${{ matrix.lua.suffix }}.exe
+        ./LuaBridgeTests${{ matrix.lua.suffix }}Reflect.exe
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaC.exe
         ./LuaBridgeTests${{ matrix.lua.suffix }}Noexcept.exe
+        ./LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept.exe
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept.exe
 
   luajit:
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index a558dfd9..273a60fc 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -55,16 +55,20 @@ jobs:
       run: |
         cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
           LuaBridgeTests${{ matrix.lua.suffix }} \
+          LuaBridgeTests${{ matrix.lua.suffix }}Reflect \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaC \
           LuaBridgeTests${{ matrix.lua.suffix }}Noexcept \
+          LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept \
           LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
 
     - name: Test Lua ${{ matrix.lua.version }}
       working-directory: ${{runner.workspace}}/build/Tests
       run: |
         ./LuaBridgeTests${{ matrix.lua.suffix }}
+        ./LuaBridgeTests${{ matrix.lua.suffix }}Reflect
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaC
         ./LuaBridgeTests${{ matrix.lua.suffix }}Noexcept
+        ./LuaBridgeTests${{ matrix.lua.suffix }}ReflectNoexcept
         ./LuaBridgeTests${{ matrix.lua.suffix }}LuaCNoexcept
 
     - name: Coverage Lua ${{ matrix.lua.version }}
diff --git a/Distribution/LuaBridge/LuaBridge.h b/Distribution/LuaBridge/LuaBridge.h
index a2d13260..dfb90ee7 100644
--- a/Distribution/LuaBridge/LuaBridge.h
+++ b/Distribution/LuaBridge/LuaBridge.h
@@ -7738,35 +7738,35 @@ struct function<void, ArgsPack, Start>
     }
 };
 
-template <class F, class T>
+template <class F, class T, int UV = 1>
 int invoke_member_function(lua_State* L)
 {
     using FnTraits = function_traits<F>;
 
-    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
+    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(UV)));
 
     auto ptr = Userdata::get<T>(L, 1, false);
     if (! ptr)
         raise_lua_error(L, "%s", ptr.error_cstr());
 
-    const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(1)));
+    const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(UV)));
     LUABRIDGE_ASSERT(func != nullptr);
 
     return function<typename FnTraits::result_type, typename FnTraits::argument_types, 2>::call(L, *ptr, func);
 }
 
-template <class F, class T>
+template <class F, class T, int UV = 1>
 int invoke_const_member_function(lua_State* L)
 {
     using FnTraits = function_traits<F>;
 
-    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
+    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(UV)));
 
     auto ptr = Userdata::get<T>(L, 1, true);
     if (! ptr)
         raise_lua_error(L, "%s", ptr.error_cstr());
 
-    const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(1)));
+    const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(UV)));
     LUABRIDGE_ASSERT(func != nullptr);
 
     return function<typename FnTraits::result_type, typename FnTraits::argument_types, 2>::call(L, *ptr, func);
@@ -7834,27 +7834,27 @@ int invoke_const_member_cfunction(lua_State* L)
 #endif
 }
 
-template <class F>
+template <class F, int UV = 1>
 int invoke_proxy_function(lua_State* L)
 {
     using FnTraits = function_traits<F>;
 
-    LUABRIDGE_ASSERT(lua_islightuserdata(L, lua_upvalueindex(1)));
+    LUABRIDGE_ASSERT(lua_islightuserdata(L, lua_upvalueindex(UV)));
 
-    auto func = reinterpret_cast<F>(lua_touserdata(L, lua_upvalueindex(1)));
+    auto func = reinterpret_cast<F>(lua_touserdata(L, lua_upvalueindex(UV)));
     LUABRIDGE_ASSERT(func != nullptr);
 
     return function<typename FnTraits::result_type, typename FnTraits::argument_types, 1>::call(L, func);
 }
 
-template <class F>
+template <class F, int UV = 1>
 int invoke_proxy_functor(lua_State* L)
 {
     using FnTraits = function_traits<std::remove_reference_t<F>>;
 
-    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
+    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(UV)));
 
-    auto& func = *align<std::remove_reference_t<F>>(lua_touserdata(L, lua_upvalueindex(1)));
+    auto& func = *align<std::remove_reference_t<F>>(lua_touserdata(L, lua_upvalueindex(UV)));
 
     return function<typename FnTraits::result_type, typename FnTraits::argument_types, 1>::call(L, func);
 }
@@ -7879,14 +7879,14 @@ inline int invoke_safe_cfunction(lua_State* L)
 }
 #endif
 
-template <class F>
+template <class F, int UV = 1>
 int invoke_proxy_constructor(lua_State* L)
 {
     using FnTraits = function_traits<F>;
 
-    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
+    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(UV)));
 
-    auto& func = *align<F>(lua_touserdata(L, lua_upvalueindex(1)));
+    auto& func = *align<F>(lua_touserdata(L, lua_upvalueindex(UV)));
 
     function<void, typename FnTraits::argument_types, 1>::call(L, func);
 
@@ -7914,7 +7914,7 @@ struct OverloadEntry
     int arity;           
     TypeChecker checker; 
 
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
     std::string returnType;                
     std::vector<std::string> paramTypes;   
     std::vector<std::string> paramHints;   
@@ -7923,6 +7923,8 @@ struct OverloadEntry
 
 struct OverloadSet
 {
+    static constexpr uint32_t kMagic = 0x4C425246u; 
+    uint32_t magic = kMagic;
     std::vector<OverloadEntry> entries;
 };
 
@@ -8068,6 +8070,29 @@ inline void push_function(lua_State* L, F&& f, const char* debugname)
     lua_pushcclosure_x(L, &invoke_proxy_functor<F>, debugname, 1);
 }
 
+template <class ReturnType, class... Params>
+inline void push_function_reflect(lua_State* L, ReturnType (*fp)(Params...), const char* debugname)
+{
+    using FnType = ReturnType (*)(Params...);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class ReturnType, class... Params>
+inline void push_function_reflect(lua_State* L, ReturnType (*fp)(Params...) noexcept, const char* debugname)
+{
+    using FnType = ReturnType (*)(Params...) noexcept;
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class F, class = std::enable_if<is_callable_v<F> && !std::is_pointer_v<F> && !std::is_member_function_pointer_v<F>>>
+inline void push_function_reflect(lua_State* L, F&& f, const char* debugname)
+{
+    lua_newuserdata_aligned<F>(L, std::forward<F>(f));
+    lua_pushcclosure_x(L, &invoke_proxy_functor<F, 2>, debugname, 2);
+}
+
 template <class T>
 void push_member_function(lua_State* L, lua_CFunction fp, const char* debugname)
 {
@@ -8230,6 +8255,118 @@ void push_member_function(lua_State* L, int (U::*mfp)(lua_State*) const, const c
     lua_pushcclosure_x(L, &invoke_const_member_cfunction<T>, debugname, 1);
 }
 
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(T*, Params...), const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(T&, Params...), const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(T*, Params...) noexcept, const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(T&, Params...) noexcept, const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(const T*, Params...), const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(const T&, Params...), const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(const T*, Params...) noexcept, const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(const T&, Params...) noexcept, const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class U, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (U::*mfp)(Params...), const char* debugname)
+{
+    static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
+    using F = decltype(mfp);
+    new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
+    lua_pushcclosure_x(L, &invoke_member_function<F, T, 2>, debugname, 2);
+}
+
+template <class T, class U, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (U::*mfp)(Params...) noexcept, const char* debugname)
+{
+    static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
+    using F = decltype(mfp);
+    new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
+    lua_pushcclosure_x(L, &invoke_member_function<F, T, 2>, debugname, 2);
+}
+
+template <class T, class U, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (U::*mfp)(Params...) const, const char* debugname)
+{
+    static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
+    using F = decltype(mfp);
+    new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
+    lua_pushcclosure_x(L, &invoke_const_member_function<F, T, 2>, debugname, 2);
+}
+
+template <class T, class U, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (U::*mfp)(Params...) const noexcept, const char* debugname)
+{
+    static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
+    using F = decltype(mfp);
+    new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
+    lua_pushcclosure_x(L, &invoke_const_member_function<F, T, 2>, debugname, 2);
+}
+
+template <class T, class F, class = std::enable_if<
+    is_callable_v<F> &&
+        std::is_object_v<F> &&
+        !std::is_pointer_v<F> &&
+        !std::is_member_function_pointer_v<F>>>
+void push_member_function_reflect(lua_State* L, F&& f, const char* debugname)
+{
+    static_assert(std::is_same_v<T, remove_cvref_t<std::remove_pointer_t<function_argument_or_void_t<0, F>>>>);
+    lua_newuserdata_aligned<F>(L, std::forward<F>(f));
+    lua_pushcclosure_x(L, &invoke_proxy_functor<F, 2>, debugname, 2);
+}
+
 template <class T, class = std::enable_if_t<
     (std::is_base_of_v<T, LuaRef> || !detail::is_callable_v<T*>)>>
 void push_property_getter(lua_State* L, const T* value, const char* debugname)
@@ -8551,16 +8688,30 @@ struct constructor
 {
     static T* construct(const Args& args)
     {
-        auto alloc = [](auto&&... args) { return new T(std::forward<decltype(args)>(args)...); };
-
-        return std::apply(alloc, args);
+        if constexpr (std::is_aggregate_v<T>)
+        {
+            auto alloc = [](auto&&... args) { return new T{std::forward<decltype(args)>(args)...}; };
+            return std::apply(alloc, args);
+        }
+        else
+        {
+            auto alloc = [](auto&&... args) { return new T(std::forward<decltype(args)>(args)...); };
+            return std::apply(alloc, args);
+        }
     }
 
     static T* construct(void* ptr, const Args& args)
     {
-        auto alloc = [ptr](auto&&... args) { return new (ptr) T(std::forward<decltype(args)>(args)...); };
-
-        return std::apply(alloc, args);
+        if constexpr (std::is_aggregate_v<T>)
+        {
+            auto alloc = [ptr](auto&&... args) { return new (ptr) T{std::forward<decltype(args)>(args)...}; };
+            return std::apply(alloc, args);
+        }
+        else
+        {
+            auto alloc = [ptr](auto&&... args) { return new (ptr) T(std::forward<decltype(args)>(args)...); };
+            return std::apply(alloc, args);
+        }
     }
 };
 
@@ -8958,26 +9109,14 @@ inline std::vector<OverloadInfo> getOverloadInfos(lua_State* L, int funcIdx)
         return { OverloadInfo{} };
     }
 
-    bool isOverloadSet = isfulluserdata(L, -1);
-    lua_pop(L, 1); 
-
-    if (!isOverloadSet)
+    OverloadSet* overload_set = nullptr;
+    if (isfulluserdata(L, -1))
     {
-        
-        return { OverloadInfo{} };
+        auto* candidate = align<OverloadSet>(lua_touserdata(L, -1));
+        if (candidate && candidate->magic == OverloadSet::kMagic)
+            overload_set = candidate;
     }
-
-    const char* uv2name = lua_getupvalue(L, funcIdx, 2);
-    bool hasTable = (uv2name != nullptr) && lua_istable(L, -1);
-    if (uv2name != nullptr)
-        lua_pop(L, 1); 
-
-    if (!hasTable)
-        return { OverloadInfo{} };
-
-    lua_getupvalue(L, funcIdx, 1);
-    auto* overload_set = align<OverloadSet>(lua_touserdata(L, -1));
-    lua_pop(L, 1);
+    lua_pop(L, 1); 
 
     if (!overload_set || overload_set->entries.empty())
         return { OverloadInfo{} };
@@ -8989,7 +9128,7 @@ inline std::vector<OverloadInfo> getOverloadInfos(lua_State* L, int funcIdx)
     {
         OverloadInfo info;
 
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
         info.returnType = entry.returnType;
         for (std::size_t i = 0; i < entry.paramTypes.size(); ++i)
         {
@@ -9021,7 +9160,7 @@ inline bool isClassStaticTable(lua_State* L, int tableIdx)
     if (!lua_getmetatable(L, tableIdx)) 
         return false;
 
-    lua_rawgetp(L, -1, getClassKey()); 
+    lua_rawgetp_x(L, -1, getClassKey()); 
     bool result = lua_istable(L, -1);
     lua_pop(L, 1); 
 
@@ -9040,25 +9179,25 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
 
     int mtIdx = lua_absindex(L, -1);
 
-    lua_rawgetp(L, mtIdx, getClassKey());
+    lua_rawgetp_x(L, mtIdx, getClassKey());
     int clIdx = lua_absindex(L, -1);
 
     ClassInspectInfo cls;
 
-    lua_rawgetp(L, clIdx, getTypeKey());
+    lua_rawgetp_x(L, clIdx, getTypeKey());
     if (lua_isstring(L, -1))
         cls.name = stripConst(lua_tostring(L, -1));
     lua_pop(L, 1);
 
-    lua_rawgetp(L, clIdx, getParentKey());
+    lua_rawgetp_x(L, clIdx, getParentKey());
     if (lua_istable(L, -1))
     {
         int parIdx = lua_absindex(L, -1);
-        int len = static_cast<int>(luaL_len(L, parIdx));
+        int len = get_length(L, parIdx);
         for (int i = 1; i <= len; ++i)
         {
             lua_rawgeti(L, parIdx, i);
-            lua_rawgetp(L, -1, getTypeKey());
+            lua_rawgetp_x(L, -1, getTypeKey());
             if (lua_isstring(L, -1))
             {
                 std::string baseName = stripConst(lua_tostring(L, -1));
@@ -9071,13 +9210,13 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
     lua_pop(L, 1); 
 
     std::set<std::string> instPropget;
-    lua_rawgetp(L, clIdx, getPropgetKey());
+    lua_rawgetp_x(L, clIdx, getPropgetKey());
     if (lua_istable(L, -1))
         instPropget = collectTableKeys(L, -1);
     lua_pop(L, 1);
 
     std::set<std::string> instPropsetReal;
-    lua_rawgetp(L, clIdx, getPropsetKey());
+    lua_rawgetp_x(L, clIdx, getPropsetKey());
     if (lua_istable(L, -1))
     {
         int psIdx = lua_absindex(L, -1);
@@ -9130,13 +9269,13 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
     }
 
     std::set<std::string> stPropget;
-    lua_rawgetp(L, mtIdx, getPropgetKey());
+    lua_rawgetp_x(L, mtIdx, getPropgetKey());
     if (lua_istable(L, -1))
         stPropget = collectTableKeys(L, -1);
     lua_pop(L, 1);
 
     std::set<std::string> stPropsetReal;
-    lua_rawgetp(L, mtIdx, getPropsetKey());
+    lua_rawgetp_x(L, mtIdx, getPropsetKey());
     if (lua_istable(L, -1))
     {
         int psIdx = lua_absindex(L, -1);
@@ -9165,7 +9304,7 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
 
     static const std::set<std::string> staticSkipKeys{ "__index", "__newindex", "__metatable" };
 
-    lua_rawgetp(L, mtIdx, getClassKey()); 
+    lua_rawgetp_x(L, mtIdx, getClassKey()); 
     lua_pop(L, 1);
 
     lua_pushnil(L);
@@ -9207,13 +9346,13 @@ inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::
     info.name = std::move(name);
 
     std::set<std::string> nsPropget;
-    lua_rawgetp(L, nsIdx, getPropgetKey());
+    lua_rawgetp_x(L, nsIdx, getPropgetKey());
     if (lua_istable(L, -1))
         nsPropget = collectTableKeys(L, -1);
     lua_pop(L, 1);
 
     int nsPropsetTableIdx = 0;
-    lua_rawgetp(L, nsIdx, getPropsetKey());
+    lua_rawgetp_x(L, nsIdx, getPropsetKey());
     if (lua_istable(L, -1))
         nsPropsetTableIdx = lua_absindex(L, -1);
     
@@ -9301,21 +9440,21 @@ template <class T>
 [[nodiscard]] ClassInspectInfo inspect(lua_State* L)
 {
     
-    lua_rawgetp(L, LUA_REGISTRYINDEX, detail::getClassRegistryKey<T>());
+    lua_rawgetp_x(L, LUA_REGISTRYINDEX, detail::getClassRegistryKey<T>());
     if (!lua_istable(L, -1))
     {
         lua_pop(L, 1);
         return {};
     }
     
-    lua_rawgetp(L, -1, detail::getStaticKey());
+    lua_rawgetp_x(L, -1, detail::getStaticKey());
     if (!lua_istable(L, -1))
     {
         lua_pop(L, 2);
         return {};
     }
     
-    lua_rawgetp(L, -1, detail::getClassKey());
+    lua_rawgetp_x(L, -1, detail::getClassKey());
     const bool isClass = lua_istable(L, -1);
     lua_pop(L, 1);
 
@@ -9335,7 +9474,7 @@ template <class T>
 {
     if (namespaceName == nullptr || namespaceName[0] == '\0')
     {
-        lua_pushglobaltable(L);
+        lua_getglobal(L, "_G");
     }
     else
     {
@@ -9407,19 +9546,16 @@ class ConsoleVisitor : public InspectVisitor
         ++depth_;
     }
 
-    void endNamespace(const NamespaceInspectInfo& 
-) override
+    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
     {
         --depth_;
         indent();
         out_ << "}\n";
     }
 
-    void visitFreeMember(const NamespaceInspectInfo& 
-, const MemberInfo& m) override
+    void visitFreeMember([[maybe_unused]] const NamespaceInspectInfo& ns, const MemberInfo& m) override
     {
-        emitMember(m, 
-"");
+        emitMember(m, "");
     }
 
     void beginClass(const ClassInspectInfo& cls) override
@@ -9439,8 +9575,7 @@ class ConsoleVisitor : public InspectVisitor
         ++depth_;
     }
 
-    void endClass(const ClassInspectInfo& 
-) override
+    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
         --depth_;
         indent();
@@ -9480,7 +9615,7 @@ class ConsoleVisitor : public InspectVisitor
         return ov.returnType.empty() ? "any" : ov.returnType;
     }
 
-    void emitMember(const MemberInfo& m, const std::string& className) const
+    void emitMember(const MemberInfo& m, [[maybe_unused]] const std::string& className) const
     {
         switch (m.kind)
         {
@@ -9510,15 +9645,13 @@ class ConsoleVisitor : public InspectVisitor
             {
                 indent();
                 if (isStatic) out_ << "static ";
-                out_ << m.name << "(" << paramStr(m.overloads[i]) << "): "
-                     << retStr(m.overloads[i]) << ";\n";
+                out_ << m.name << "(" << paramStr(m.overloads[i]) << "): " << retStr(m.overloads[i]) << ";\n";
             }
             break;
         }
         default:
             break;
         }
-        (void)className;
     }
 
     std::ostream& out_;
@@ -9538,8 +9671,7 @@ class LuaLSVisitor : public InspectVisitor
         ns_ = ns.name == "_G" ? "" : ns.name;
     }
 
-    void endNamespace(const NamespaceInspectInfo& 
-) override {}
+    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override {}
 
     void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) override
     {
@@ -9552,6 +9684,7 @@ class LuaLSVisitor : public InspectVisitor
             if (!ov.returnType.empty() && ov.returnType != "void")
                 out_ << "---@return " << luaType(ov.returnType) << "\n";
         }
+
         std::string qual = ns_.empty() ? "" : (ns_ + ".");
         out_ << "function " << qual << m.name << "(";
         if (!m.overloads.empty())
@@ -9573,8 +9706,7 @@ class LuaLSVisitor : public InspectVisitor
 
     }
 
-    void endClass(const ClassInspectInfo& 
-) override
+    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
         out_ << "local " << curClass_ << " = {}\n\n";
         curClass_.clear();
@@ -9768,15 +9900,13 @@ class LuaProxyVisitor : public InspectVisitor
         out_ << cls.name << ".__index = " << cls.name << "\n\n";
     }
 
-    void endClass(const ClassInspectInfo& 
-) override
+    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
         curClass_.clear();
         out_ << "\n";
     }
 
-    void visitMember(const ClassInspectInfo& 
-, const MemberInfo& m) override
+    void visitMember([[maybe_unused]] const ClassInspectInfo& cls, const MemberInfo& m) override
     {
         if (m.overloads.empty())
             return;
@@ -9842,8 +9972,7 @@ class JsonVisitor : public InspectVisitor
         firstClass_ = true;
     }
 
-    void endNamespace(const NamespaceInspectInfo& 
-) override
+    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
     {
         --depth_;
         out_ << "\n";
@@ -9870,8 +9999,7 @@ class JsonVisitor : public InspectVisitor
         firstMember_ = true;
     }
 
-    void endClass(const ClassInspectInfo& 
-) override
+    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
         --depth_;
         out_ << "\n";
@@ -9880,8 +10008,7 @@ class JsonVisitor : public InspectVisitor
         indent(); out_ << "}";
     }
 
-    void visitMember(const ClassInspectInfo& 
-, const MemberInfo& m) override
+    void visitMember([[maybe_unused]] const ClassInspectInfo& cls, const MemberInfo& m) override
     {
         if (!firstMember_) out_ << ",\n";
         firstMember_ = false;
@@ -9960,14 +10087,12 @@ class LuaTableVisitor : public InspectVisitor
         subNsIdx_ = 1;
     }
 
-    void endNamespace(const NamespaceInspectInfo& 
-) override
+    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
     {
         
     }
 
-    void visitFreeMember(const NamespaceInspectInfo& 
-, const MemberInfo& m) override
+    void visitFreeMember([[maybe_unused]] const NamespaceInspectInfo& ns, const MemberInfo& m) override
     {
         lua_getfield(L_, -1, "freeMembers");
         pushMemberInfo(m);
@@ -9994,8 +10119,7 @@ class LuaTableVisitor : public InspectVisitor
         memberIdx_ = 1;
     }
 
-    void endClass(const ClassInspectInfo& 
-) override
+    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
         
         lua_getfield(L_, -2, "classes");
@@ -10004,8 +10128,7 @@ class LuaTableVisitor : public InspectVisitor
         lua_pop(L_, 2); 
     }
 
-    void visitMember(const ClassInspectInfo& 
-, const MemberInfo& m) override
+    void visitMember([[maybe_unused]] const ClassInspectInfo& cls, const MemberInfo& m) override
     {
         lua_getfield(L_, -1, "members");
         pushMemberInfo(m);
@@ -10678,28 +10801,30 @@ template <class F>
 
 #if defined(LUABRIDGE_ENABLE_REFLECT)
 
-template <class Tuple>
-[[nodiscard]] std::vector<std::string> reflect_param_type_names()
+template <class Tuple, std::size_t... I>
+void reflect_param_type_names_impl(std::vector<std::string>& result, std::index_sequence<I...>)
 {
-    std::vector<std::string> result;
-
-    [&]<std::size_t... I>(std::index_sequence<I...>)
-    {
-        (
-            [&]
-            {
-                using ParamT = std::tuple_element_t<I, Tuple>;
+    
+    (
+        [&]()
+        {
+            using ParamT = std::tuple_element_t<I, Tuple>;
 
-                constexpr bool isLuaState =
-                    std::is_pointer_v<ParamT> &&
-                    std::is_same_v<std::remove_const_t<std::remove_pointer_t<ParamT>>, lua_State>;
+            constexpr bool isLuaState =
+                std::is_pointer_v<ParamT> &&
+                std::is_same_v<std::remove_const_t<std::remove_pointer_t<ParamT>>, lua_State>;
 
-                if constexpr (!isLuaState)
-                    result.push_back(std::string(typeName<std::remove_cvref_t<ParamT>>()));
-            }(),
-            ...);
-    }(std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+            if constexpr (!isLuaState)
+                result.push_back(std::string(typeName<std::remove_cvref_t<ParamT>>()));
+        }(),
+        ...);
+}
 
+template <class Tuple>
+[[nodiscard]] std::vector<std::string> reflect_param_type_names()
+{
+    std::vector<std::string> result;
+    reflect_param_type_names_impl<Tuple>(result, std::make_index_sequence<std::tuple_size_v<Tuple>>{});
     return result;
 }
 
@@ -12853,35 +12978,31 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
                 
                 ([&]
                 {
-                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
-                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
-
-                    detail::OverloadEntry entry;
                     if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
                     {
+                        auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                        auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                        detail::OverloadEntry entry;
                         using ArgsPack = detail::function_arguments_t<Functions>;
-                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
-                        entry.checker = &detail::overload_type_checker<ArgsPack>;
-                        entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                        entry.arity = -1;
+                        entry.checker = nullptr;
+                        entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                         entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         if constexpr (detail::is_function_with_hints_v<Functions>)
                             entry.paramHints = functions.hints;
+                        overload_set->entries.push_back(std::move(entry));
+
+                        detail::push_function_reflect(L, detail::get_underlying(std::move(functions)), name);
                     }
                     else
                     {
-                        entry.arity = -1;
-                        entry.checker = nullptr;
+                        detail::push_function(L, detail::get_underlying(std::move(functions)), name);
                     }
-                    overload_set->entries.push_back(std::move(entry));
-
-                    lua_createtable(L, 1, 0);
-                    detail::push_function(L, detail::get_underlying(std::move(functions)), name);
-                    lua_rawseti(L, -2, 1);
-                    lua_pushcclosure_x(L, &detail::try_overload_functions<false>, name, 2);
 
                 } (), ...);
 #else
@@ -12911,8 +13032,8 @@ class Namespace : public detail::Registrar
                         using ArgsPack = detail::function_arguments_t<Functions>;
                         entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                         entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                        entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                        entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                         entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         if constexpr (detail::is_function_with_hints_v<Functions>)
                             entry.paramHints = functions.hints;
@@ -13055,46 +13176,43 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
                 
                 ([&]
                 {
-                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
-                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
-
-                    detail::OverloadEntry entry;
                     if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
                     {
+                        auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                        auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                        detail::OverloadEntry entry;
                         if constexpr (detail::is_proxy_member_function_v<T, Functions>)
                         {
                             using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
-                            entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
-                            entry.checker = &detail::overload_type_checker<ArgsPack>;
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.arity = -1;
+                            entry.checker = nullptr;
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         }
                         else
                         {
                             using ArgsPack = detail::function_arguments_t<Functions>;
-                            entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
-                            entry.checker = &detail::overload_type_checker<ArgsPack>;
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.arity = -1;
+                            entry.checker = nullptr;
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         }
                         if constexpr (detail::is_function_with_hints_v<Functions>)
                             entry.paramHints = functions.hints;
+                        overload_set->entries.push_back(std::move(entry));
+
+                        detail::push_member_function_reflect<T>(L, detail::get_underlying(std::move(functions)), name);
                     }
                     else
                     {
-                        entry.arity = -1;
-                        entry.checker = nullptr;
+                        
+                        detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
                     }
-                    overload_set->entries.push_back(std::move(entry));
-
-                    lua_createtable(L, 1, 0);
-                    detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
-                    lua_rawseti(L, -2, 1);
-                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, name, 2);
 
                 } (), ...);
 #else
@@ -13141,8 +13259,8 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                             if constexpr (detail::is_function_with_hints_v<Functions>)
                                 entry.paramHints = functions.hints;
@@ -13153,8 +13271,8 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::function_arguments_t<Functions>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                             if constexpr (detail::is_function_with_hints_v<Functions>)
                                 entry.paramHints = functions.hints;
@@ -13208,8 +13326,8 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                             if constexpr (detail::is_function_with_hints_v<Functions>)
                                 entry.paramHints = functions.hints;
@@ -13220,8 +13338,8 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::function_arguments_t<Functions>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                             if constexpr (detail::is_function_with_hints_v<Functions>)
                                 entry.paramHints = functions.hints;
@@ -13304,7 +13422,7 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
                 
                 ([&]
                 {
@@ -13314,16 +13432,13 @@ class Namespace : public detail::Registrar
                     auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
 
                     detail::OverloadEntry entry;
-                    entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
-                    entry.checker = &detail::overload_type_checker<ArgsPack>;
+                    entry.arity = -1;
+                    entry.checker = nullptr;
                     entry.returnType = std::string(detail::typeName<T>());
                     entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                     overload_set->entries.push_back(std::move(entry));
 
-                    lua_createtable(L, 1, 0);
-                    lua_pushcclosure_x(L, &detail::constructor_placement_proxy<T, ArgsPack>, className, 0);
-                    lua_rawseti(L, -2, 1);
-                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, className, 2);
+                    lua_pushcclosure_x(L, &detail::constructor_placement_proxy<T, ArgsPack>, className, 1);
 
                 } (), ...);
 #else
@@ -13346,7 +13461,7 @@ class Namespace : public detail::Registrar
                     detail::OverloadEntry entry;
                     entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                     entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
                     entry.returnType = std::string(detail::typeName<T>());
                     entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
 #endif
@@ -13389,29 +13504,25 @@ class Namespace : public detail::Registrar
                     using InnerF = detail::unwrap_fn_type_t<Functions>;
                     using F = detail::constructor_forwarder<T, InnerF>;
 
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
                     
-                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
-                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
-
                     {
+                        auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                        auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
                         
                         using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<InnerF>>;
                         detail::OverloadEntry entry;
-                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<InnerF, lua_State*>) - 1;
-                        entry.checker = &detail::overload_type_checker<ArgsPack>;
+                        entry.arity = -1;
+                        entry.checker = nullptr;
                         entry.returnType = std::string(detail::typeName<T>());
                         entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         if constexpr (detail::is_function_with_hints_v<Functions>)
                             entry.paramHints = functions.hints;
                         overload_set->entries.push_back(std::move(entry));
                     }
-
-                    lua_createtable(L, 1, 0);
-                    lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions))));
-                    lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1);
-                    lua_rawseti(L, -2, 1);
-                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, className, 2);
+                    
+                    lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions)))); 
+                    lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F, 2>, className, 2);
 #else
                     lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions)))); 
                     lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1); 
@@ -13440,7 +13551,7 @@ class Namespace : public detail::Registrar
                         using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<InnerF>>;
                         entry.arity = static_cast<int>(detail::function_arity_excluding_v<InnerF, lua_State*>) - 1;
                         entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
                         entry.returnType = std::string(detail::typeName<T>());
                         entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         if constexpr (detail::is_function_with_hints_v<Functions>)
@@ -13975,35 +14086,32 @@ class Namespace : public detail::Registrar
 
         if constexpr (sizeof...(Functions) == 1)
         {
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
             
             ([&]
             {
-                auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
-                auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
-
-                detail::OverloadEntry entry;
                 if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
                 {
+                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                    detail::OverloadEntry entry;
                     using ArgsPack = detail::function_arguments_t<Functions>;
-                    entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
-                    entry.checker = &detail::overload_type_checker<ArgsPack>;
-                    entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                    entry.arity = -1; 
+                    entry.checker = nullptr; 
+                    entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                     entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                     if constexpr (detail::is_function_with_hints_v<Functions>)
                         entry.paramHints = functions.hints;
+                    overload_set->entries.push_back(std::move(entry));
+
+                    detail::push_function_reflect(L, detail::get_underlying(std::move(functions)), name);
                 }
                 else
                 {
-                    entry.arity = -1;
-                    entry.checker = nullptr;
+                    
+                    detail::push_function(L, detail::get_underlying(std::move(functions)), name);
                 }
-                overload_set->entries.push_back(std::move(entry));
-
-                lua_createtable(L, 1, 0);
-                detail::push_function(L, detail::get_underlying(std::move(functions)), name);
-                lua_rawseti(L, -2, 1);
-                lua_pushcclosure_x(L, &detail::try_overload_functions<false>, name, 2);
 
             } (), ...);
 #else
@@ -14033,8 +14141,8 @@ class Namespace : public detail::Registrar
                     using ArgsPack = detail::function_arguments_t<Functions>;
                     entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                     entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                    entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                    entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                     entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                     if constexpr (detail::is_function_with_hints_v<Functions>)
                         entry.paramHints = functions.hints;
diff --git a/Source/LuaBridge/Inspect.h b/Source/LuaBridge/Inspect.h
index d8a4a8a5..1dc75ac1 100644
--- a/Source/LuaBridge/Inspect.h
+++ b/Source/LuaBridge/Inspect.h
@@ -187,36 +187,25 @@ inline std::vector<OverloadInfo> getOverloadInfos(lua_State* L, int funcIdx)
     if (!lua_isfunction(L, funcIdx))
         return { OverloadInfo{} };
 
-    // Check upvalue 1 for an OverloadSet userdata
+    // Check upvalue 1 for an OverloadSet userdata identified by its magic cookie.
+    // This handles two layouts:
+    //   Multi-overload:           upvalue[1]=OverloadSet, upvalue[2]=table of functions
+    //   Single-overload REFLECT:  upvalue[1]=OverloadSet, upvalue[2]=function data directly
     const char* uv1name = lua_getupvalue(L, funcIdx, 1);
     if (uv1name == nullptr)
     {
-        // No upvalues — bare cfunction (single function, no metadata available)
+        // No upvalues — bare cfunction, no metadata available
         return { OverloadInfo{} };
     }
 
-    bool isOverloadSet = isfulluserdata(L, -1);
-    lua_pop(L, 1); // pop upvalue 1
-
-    if (!isOverloadSet)
+    OverloadSet* overload_set = nullptr;
+    if (isfulluserdata(L, -1))
     {
-        // upvalue 1 is not a full userdata (e.g. lightuserdata function pointer)
-        return { OverloadInfo{} };
+        auto* candidate = align<OverloadSet>(lua_touserdata(L, -1));
+        if (candidate && candidate->magic == OverloadSet::kMagic)
+            overload_set = candidate;
     }
-
-    // Confirm upvalue 2 is a table (the flat function table)
-    const char* uv2name = lua_getupvalue(L, funcIdx, 2);
-    bool hasTable = (uv2name != nullptr) && lua_istable(L, -1);
-    if (uv2name != nullptr)
-        lua_pop(L, 1); // pop upvalue 2
-
-    if (!hasTable)
-        return { OverloadInfo{} };
-
-    // Re-fetch upvalue 1 to read the OverloadSet
-    lua_getupvalue(L, funcIdx, 1);
-    auto* overload_set = align<OverloadSet>(lua_touserdata(L, -1));
-    lua_pop(L, 1);
+    lua_pop(L, 1); // pop upvalue 1
 
     if (!overload_set || overload_set->entries.empty())
         return { OverloadInfo{} };
@@ -228,7 +217,7 @@ inline std::vector<OverloadInfo> getOverloadInfos(lua_State* L, int funcIdx)
     {
         OverloadInfo info;
 
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
         info.returnType = entry.returnType;
         for (std::size_t i = 0; i < entry.paramTypes.size(); ++i)
         {
@@ -263,7 +252,7 @@ inline bool isClassStaticTable(lua_State* L, int tableIdx)
     if (!lua_getmetatable(L, tableIdx)) // always works from C regardless of __metatable
         return false;
 
-    lua_rawgetp(L, -1, getClassKey()); // mt[getClassKey()] = cl ?
+    lua_rawgetp_x(L, -1, getClassKey()); // mt[getClassKey()] = cl ?
     bool result = lua_istable(L, -1);
     lua_pop(L, 1); // pop cl / nil
 
@@ -287,27 +276,27 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
     int mtIdx = lua_absindex(L, -1);
 
     // Get the class table cl = mt[getClassKey()]
-    lua_rawgetp(L, mtIdx, getClassKey());
+    lua_rawgetp_x(L, mtIdx, getClassKey());
     int clIdx = lua_absindex(L, -1);
 
     ClassInspectInfo cls;
 
     // 1. Class name
-    lua_rawgetp(L, clIdx, getTypeKey());
+    lua_rawgetp_x(L, clIdx, getTypeKey());
     if (lua_isstring(L, -1))
         cls.name = stripConst(lua_tostring(L, -1));
     lua_pop(L, 1);
 
     // 2. Base classes from parent list
-    lua_rawgetp(L, clIdx, getParentKey());
+    lua_rawgetp_x(L, clIdx, getParentKey());
     if (lua_istable(L, -1))
     {
         int parIdx = lua_absindex(L, -1);
-        int len = static_cast<int>(luaL_len(L, parIdx));
+        int len = get_length(L, parIdx);
         for (int i = 1; i <= len; ++i)
         {
             lua_rawgeti(L, parIdx, i);
-            lua_rawgetp(L, -1, getTypeKey());
+            lua_rawgetp_x(L, -1, getTypeKey());
             if (lua_isstring(L, -1))
             {
                 std::string baseName = stripConst(lua_tostring(L, -1));
@@ -321,14 +310,14 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
 
     // 3. Collect instance property names
     std::set<std::string> instPropget;
-    lua_rawgetp(L, clIdx, getPropgetKey());
+    lua_rawgetp_x(L, clIdx, getPropgetKey());
     if (lua_istable(L, -1))
         instPropget = collectTableKeys(L, -1);
     lua_pop(L, 1);
 
     // Collect instance property names that have a real (non-readonly-sentinel) setter
     std::set<std::string> instPropsetReal;
-    lua_rawgetp(L, clIdx, getPropsetKey());
+    lua_rawgetp_x(L, clIdx, getPropsetKey());
     if (lua_istable(L, -1))
     {
         int psIdx = lua_absindex(L, -1);
@@ -384,14 +373,14 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
 
     // 6. Collect static property names
     std::set<std::string> stPropget;
-    lua_rawgetp(L, mtIdx, getPropgetKey());
+    lua_rawgetp_x(L, mtIdx, getPropgetKey());
     if (lua_istable(L, -1))
         stPropget = collectTableKeys(L, -1);
     lua_pop(L, 1);
 
     // Collect static property names that have a real (non-readonly-sentinel) setter
     std::set<std::string> stPropsetReal;
-    lua_rawgetp(L, mtIdx, getPropsetKey());
+    lua_rawgetp_x(L, mtIdx, getPropsetKey());
     if (lua_istable(L, -1))
     {
         int psIdx = lua_absindex(L, -1);
@@ -422,7 +411,7 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
     // 8. Iterate mt for static methods + constructor
     static const std::set<std::string> staticSkipKeys{ "__index", "__newindex", "__metatable" };
 
-    lua_rawgetp(L, mtIdx, getClassKey()); // just to see mt's string keys, iterate mt directly
+    lua_rawgetp_x(L, mtIdx, getClassKey()); // just to see mt's string keys, iterate mt directly
     lua_pop(L, 1);
 
     lua_pushnil(L);
@@ -466,14 +455,14 @@ inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::
 
     // Namespace-level properties (stored directly on the namespace table via getPropgetKey)
     std::set<std::string> nsPropget;
-    lua_rawgetp(L, nsIdx, getPropgetKey());
+    lua_rawgetp_x(L, nsIdx, getPropgetKey());
     if (lua_istable(L, -1))
         nsPropget = collectTableKeys(L, -1);
     lua_pop(L, 1);
 
     // Get the propset table so we can check each setter individually
     int nsPropsetTableIdx = 0;
-    lua_rawgetp(L, nsIdx, getPropsetKey());
+    lua_rawgetp_x(L, nsIdx, getPropsetKey());
     if (lua_istable(L, -1))
         nsPropsetTableIdx = lua_absindex(L, -1);
     // leave propset table on stack; we pop it after the loop
@@ -573,7 +562,7 @@ template <class T>
 [[nodiscard]] ClassInspectInfo inspect(lua_State* L)
 {
     // Load the class table (cl) directly from the Lua registry
-    lua_rawgetp(L, LUA_REGISTRYINDEX, detail::getClassRegistryKey<T>());
+    lua_rawgetp_x(L, LUA_REGISTRYINDEX, detail::getClassRegistryKey<T>());
     if (!lua_istable(L, -1))
     {
         lua_pop(L, 1);
@@ -584,7 +573,7 @@ template <class T>
     // cl[getStaticKey()] = st  (the internal static table that acts as a metatable)
     // NOTE: this is NOT the user-visible ns["ClassName"] table; it is the metatable of that table.
     // isClassStaticTable() cannot be used here because st itself has no metatable.
-    lua_rawgetp(L, -1, detail::getStaticKey());
+    lua_rawgetp_x(L, -1, detail::getStaticKey());
     if (!lua_istable(L, -1))
     {
         lua_pop(L, 2);
@@ -593,7 +582,7 @@ template <class T>
     // Stack: ..., cl, st
 
     // Verify st actually belongs to a registered class: st[getClassKey()] must be a table
-    lua_rawgetp(L, -1, detail::getClassKey());
+    lua_rawgetp_x(L, -1, detail::getClassKey());
     const bool isClass = lua_istable(L, -1);
     lua_pop(L, 1);
 
@@ -607,7 +596,6 @@ template <class T>
     ClassInspectInfo result = detail::inspectClassFromStaticTable(L, lua_gettop(L));
     // inspectClassFromStaticTable pops st (used as mt) and the cl it fetched from st[getClassKey()]
     // Stack: ..., cl
-
     lua_pop(L, 1); // pop cl
     return result;
 }
@@ -625,7 +613,7 @@ template <class T>
 {
     if (namespaceName == nullptr || namespaceName[0] == '\0')
     {
-        lua_pushglobaltable(L);
+        lua_getglobal(L, "_G");
     }
     else
     {
@@ -687,9 +675,6 @@ inline void inspectAccept(lua_State* L, const char* namespaceName, InspectVisito
     accept(ns, visitor);
 }
 
-//=================================================================================================
-// Built-in visitors
-
 //=================================================================================================
 /**
  * @brief Visitor that emits TypeScript-style pseudo-code to an ostream.
@@ -723,16 +708,16 @@ class ConsoleVisitor : public InspectVisitor
         ++depth_;
     }
 
-    void endNamespace(const NamespaceInspectInfo& /*ns*/) override
+    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
     {
         --depth_;
         indent();
         out_ << "}\n";
     }
 
-    void visitFreeMember(const NamespaceInspectInfo& /*ns*/, const MemberInfo& m) override
+    void visitFreeMember([[maybe_unused]] const NamespaceInspectInfo& ns, const MemberInfo& m) override
     {
-        emitMember(m, /*className=*/"");
+        emitMember(m, "");
     }
 
     void beginClass(const ClassInspectInfo& cls) override
@@ -752,7 +737,7 @@ class ConsoleVisitor : public InspectVisitor
         ++depth_;
     }
 
-    void endClass(const ClassInspectInfo& /*cls*/) override
+    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
         --depth_;
         indent();
@@ -792,7 +777,7 @@ class ConsoleVisitor : public InspectVisitor
         return ov.returnType.empty() ? "any" : ov.returnType;
     }
 
-    void emitMember(const MemberInfo& m, const std::string& className) const
+    void emitMember(const MemberInfo& m, [[maybe_unused]] const std::string& className) const
     {
         switch (m.kind)
         {
@@ -822,15 +807,13 @@ class ConsoleVisitor : public InspectVisitor
             {
                 indent();
                 if (isStatic) out_ << "static ";
-                out_ << m.name << "(" << paramStr(m.overloads[i]) << "): "
-                     << retStr(m.overloads[i]) << ";\n";
+                out_ << m.name << "(" << paramStr(m.overloads[i]) << "): " << retStr(m.overloads[i]) << ";\n";
             }
             break;
         }
         default:
             break;
         }
-        (void)className;
     }
 
     std::ostream& out_;
@@ -858,7 +841,7 @@ class LuaLSVisitor : public InspectVisitor
         ns_ = ns.name == "_G" ? "" : ns.name;
     }
 
-    void endNamespace(const NamespaceInspectInfo& /*ns*/) override {}
+    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override {}
 
     void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) override
     {
@@ -871,6 +854,7 @@ class LuaLSVisitor : public InspectVisitor
             if (!ov.returnType.empty() && ov.returnType != "void")
                 out_ << "---@return " << luaType(ov.returnType) << "\n";
         }
+
         std::string qual = ns_.empty() ? "" : (ns_ + ".");
         out_ << "function " << qual << m.name << "(";
         if (!m.overloads.empty())
@@ -894,7 +878,7 @@ class LuaLSVisitor : public InspectVisitor
         // (will be added in visitMember below, but need the class annotation open)
     }
 
-    void endClass(const ClassInspectInfo& /*cls*/) override
+    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
         out_ << "local " << curClass_ << " = {}\n\n";
         curClass_.clear();
@@ -1094,13 +1078,13 @@ class LuaProxyVisitor : public InspectVisitor
         out_ << cls.name << ".__index = " << cls.name << "\n\n";
     }
 
-    void endClass(const ClassInspectInfo& /*cls*/) override
+    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
         curClass_.clear();
         out_ << "\n";
     }
 
-    void visitMember(const ClassInspectInfo& /*cls*/, const MemberInfo& m) override
+    void visitMember([[maybe_unused]] const ClassInspectInfo& cls, const MemberInfo& m) override
     {
         if (m.overloads.empty())
             return;
@@ -1170,7 +1154,7 @@ class JsonVisitor : public InspectVisitor
         firstClass_ = true;
     }
 
-    void endNamespace(const NamespaceInspectInfo& /*ns*/) override
+    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
     {
         --depth_;
         out_ << "\n";
@@ -1197,7 +1181,7 @@ class JsonVisitor : public InspectVisitor
         firstMember_ = true;
     }
 
-    void endClass(const ClassInspectInfo& /*cls*/) override
+    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
         --depth_;
         out_ << "\n";
@@ -1206,7 +1190,7 @@ class JsonVisitor : public InspectVisitor
         indent(); out_ << "}";
     }
 
-    void visitMember(const ClassInspectInfo& /*cls*/, const MemberInfo& m) override
+    void visitMember([[maybe_unused]] const ClassInspectInfo& cls, const MemberInfo& m) override
     {
         if (!firstMember_) out_ << ",\n";
         firstMember_ = false;
@@ -1302,12 +1286,12 @@ class LuaTableVisitor : public InspectVisitor
         subNsIdx_ = 1;
     }
 
-    void endNamespace(const NamespaceInspectInfo& /*ns*/) override
+    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
     {
         // namespace table stays on stack as the result
     }
 
-    void visitFreeMember(const NamespaceInspectInfo& /*ns*/, const MemberInfo& m) override
+    void visitFreeMember([[maybe_unused]] const NamespaceInspectInfo& ns, const MemberInfo& m) override
     {
         lua_getfield(L_, -1, "freeMembers");
         pushMemberInfo(m);
@@ -1334,7 +1318,7 @@ class LuaTableVisitor : public InspectVisitor
         memberIdx_ = 1;
     }
 
-    void endClass(const ClassInspectInfo& /*cls*/) override
+    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
         // class table is on top; store it in the namespace's "classes" array
         lua_getfield(L_, -2, "classes");
@@ -1343,7 +1327,7 @@ class LuaTableVisitor : public InspectVisitor
         lua_pop(L_, 2); // pop classes table + class table
     }
 
-    void visitMember(const ClassInspectInfo& /*cls*/, const MemberInfo& m) override
+    void visitMember([[maybe_unused]] const ClassInspectInfo& cls, const MemberInfo& m) override
     {
         lua_getfield(L_, -1, "members");
         pushMemberInfo(m);
diff --git a/Source/LuaBridge/detail/CFunctions.h b/Source/LuaBridge/detail/CFunctions.h
index 0621d1f4..dfbb2610 100644
--- a/Source/LuaBridge/detail/CFunctions.h
+++ b/Source/LuaBridge/detail/CFunctions.h
@@ -1682,35 +1682,35 @@ struct function<void, ArgsPack, Start>
  *
  * The member function pointer is in the first upvalue. The class userdata object is at the top of the Lua stack.
  */
-template <class F, class T>
+template <class F, class T, int UV = 1>
 int invoke_member_function(lua_State* L)
 {
     using FnTraits = function_traits<F>;
 
-    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
+    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(UV)));
 
     auto ptr = Userdata::get<T>(L, 1, false);
     if (! ptr)
         raise_lua_error(L, "%s", ptr.error_cstr());
 
-    const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(1)));
+    const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(UV)));
     LUABRIDGE_ASSERT(func != nullptr);
 
     return function<typename FnTraits::result_type, typename FnTraits::argument_types, 2>::call(L, *ptr, func);
 }
 
-template <class F, class T>
+template <class F, class T, int UV = 1>
 int invoke_const_member_function(lua_State* L)
 {
     using FnTraits = function_traits<F>;
 
-    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
+    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(UV)));
 
     auto ptr = Userdata::get<T>(L, 1, true);
     if (! ptr)
         raise_lua_error(L, "%s", ptr.error_cstr());
 
-    const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(1)));
+    const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(UV)));
     LUABRIDGE_ASSERT(func != nullptr);
 
     return function<typename FnTraits::result_type, typename FnTraits::argument_types, 2>::call(L, *ptr, func);
@@ -1790,14 +1790,14 @@ int invoke_const_member_cfunction(lua_State* L)
  *
  * The proxy function pointer (lightuserdata) is in the first upvalue. The class userdata object is at the top of the Lua stack.
  */
-template <class F>
+template <class F, int UV = 1>
 int invoke_proxy_function(lua_State* L)
 {
     using FnTraits = function_traits<F>;
 
-    LUABRIDGE_ASSERT(lua_islightuserdata(L, lua_upvalueindex(1)));
+    LUABRIDGE_ASSERT(lua_islightuserdata(L, lua_upvalueindex(UV)));
 
-    auto func = reinterpret_cast<F>(lua_touserdata(L, lua_upvalueindex(1)));
+    auto func = reinterpret_cast<F>(lua_touserdata(L, lua_upvalueindex(UV)));
     LUABRIDGE_ASSERT(func != nullptr);
 
     return function<typename FnTraits::result_type, typename FnTraits::argument_types, 1>::call(L, func);
@@ -1809,14 +1809,14 @@ int invoke_proxy_function(lua_State* L)
  *
  * The proxy std::function (lightuserdata) is in the first upvalue. The class userdata object is at the top of the Lua stack.
  */
-template <class F>
+template <class F, int UV = 1>
 int invoke_proxy_functor(lua_State* L)
 {
     using FnTraits = function_traits<std::remove_reference_t<F>>;
 
-    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
+    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(UV)));
 
-    auto& func = *align<std::remove_reference_t<F>>(lua_touserdata(L, lua_upvalueindex(1)));
+    auto& func = *align<std::remove_reference_t<F>>(lua_touserdata(L, lua_upvalueindex(UV)));
 
     return function<typename FnTraits::result_type, typename FnTraits::argument_types, 1>::call(L, func);
 }
@@ -1851,14 +1851,14 @@ inline int invoke_safe_cfunction(lua_State* L)
  *
  * The proxy std::function (lightuserdata) is in the first upvalue. The class userdata object will be pushed at the top of the Lua stack.
  */
-template <class F>
+template <class F, int UV = 1>
 int invoke_proxy_constructor(lua_State* L)
 {
     using FnTraits = function_traits<F>;
 
-    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
+    LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(UV)));
 
-    auto& func = *align<F>(lua_touserdata(L, lua_upvalueindex(1)));
+    auto& func = *align<F>(lua_touserdata(L, lua_upvalueindex(UV)));
 
     function<void, typename FnTraits::argument_types, 1>::call(L, func);
 
@@ -1898,7 +1898,7 @@ struct OverloadEntry
     int arity;           // -1 for variadic (lua_CFunction): always attempt
     TypeChecker checker; // nullptr for variadic: skip type pre-checking
 
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
     std::string returnType;                ///< C++ return type name (from detail::typeName)
     std::vector<std::string> paramTypes;   ///< C++ parameter type names (excluding lua_State*)
     std::vector<std::string> paramHints;   ///< Optional user-provided parameter names (from withHints)
@@ -1909,10 +1909,16 @@ struct OverloadEntry
  * @brief C++ storage for all overloads of a function.
  *
  * Stored as a Lua full userdata so it is GC'd automatically when the closure is collected.
- * The actual function closures are stored separately in a flat Lua table (upvalue 2).
+ * For multi-overload dispatch: the actual function closures are in a flat Lua table (upvalue 2).
+ * For single-overload REFLECT: the OverloadSet is upvalue[1] of the actual function closure directly.
+ *
+ * The magic field allows getOverloadInfos() to reliably distinguish this from other full-userdata
+ * upvalues (e.g. functor objects stored in invoke_proxy_functor closures).
  */
 struct OverloadSet
 {
+    static constexpr uint32_t kMagic = 0x4C425246u; // 'LBRF' — LuaBridge ReFLect sentinel
+    uint32_t magic = kMagic;
     std::vector<OverloadEntry> entries;
 };
 
@@ -1971,6 +1977,8 @@ bool overload_type_checker(lua_State* L, int start)
  *   2. Type check via Stack<T>::isInstance in C++ (no pcall) — skips clearly mismatched overloads.
  *   3. Only calls lua_pcall for type-matched candidates, eliminating failed pcalls for type mismatches.
  */
+
+
 template <bool Member>
 inline int try_overload_functions(lua_State* L)
 {
@@ -2092,6 +2100,35 @@ inline void push_function(lua_State* L, F&& f, const char* debugname)
     lua_pushcclosure_x(L, &invoke_proxy_functor<F>, debugname, 1);
 }
 
+//=================================================================================================
+// REFLECT variants of push_function: OverloadSet is already at stack top (upvalue[1]);
+// these push function data as upvalue[2] and create a 2-upvalue closure.
+
+// Generic function pointer (reflect)
+template <class ReturnType, class... Params>
+inline void push_function_reflect(lua_State* L, ReturnType (*fp)(Params...), const char* debugname)
+{
+    using FnType = ReturnType (*)(Params...);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class ReturnType, class... Params>
+inline void push_function_reflect(lua_State* L, ReturnType (*fp)(Params...) noexcept, const char* debugname)
+{
+    using FnType = ReturnType (*)(Params...) noexcept;
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+// Callable object / lambda (reflect)
+template <class F, class = std::enable_if<is_callable_v<F> && !std::is_pointer_v<F> && !std::is_member_function_pointer_v<F>>>
+inline void push_function_reflect(lua_State* L, F&& f, const char* debugname)
+{
+    lua_newuserdata_aligned<F>(L, std::forward<F>(f));
+    lua_pushcclosure_x(L, &invoke_proxy_functor<F, 2>, debugname, 2);
+}
+
 //=================================================================================================
 // Lua CFunction
 template <class T>
@@ -2262,6 +2299,127 @@ void push_member_function(lua_State* L, int (U::*mfp)(lua_State*) const, const c
     lua_pushcclosure_x(L, &invoke_const_member_cfunction<T>, debugname, 1);
 }
 
+//=================================================================================================
+// REFLECT variants of push_member_function: OverloadSet is already at stack top (upvalue[1]);
+// these push function data as upvalue[2] and create a 2-upvalue closure.
+// Only non-cfunction types are handled here; is_any_cfunction_pointer_v types skip OverloadSet.
+
+// Generic function pointer (proxy-style, first arg is T* or T&)
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(T*, Params...), const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(T&, Params...), const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(T*, Params...) noexcept, const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(T&, Params...) noexcept, const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(const T*, Params...), const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(const T&, Params...), const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(const T*, Params...) noexcept, const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+template <class T, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (*fp)(const T&, Params...) noexcept, const char* debugname)
+{
+    using FnType = decltype(fp);
+    lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
+    lua_pushcclosure_x(L, &invoke_proxy_function<FnType, 2>, debugname, 2);
+}
+
+// True member function pointers (non-const)
+template <class T, class U, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (U::*mfp)(Params...), const char* debugname)
+{
+    static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
+    using F = decltype(mfp);
+    new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
+    lua_pushcclosure_x(L, &invoke_member_function<F, T, 2>, debugname, 2);
+}
+
+template <class T, class U, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (U::*mfp)(Params...) noexcept, const char* debugname)
+{
+    static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
+    using F = decltype(mfp);
+    new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
+    lua_pushcclosure_x(L, &invoke_member_function<F, T, 2>, debugname, 2);
+}
+
+// True member function pointers (const)
+template <class T, class U, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (U::*mfp)(Params...) const, const char* debugname)
+{
+    static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
+    using F = decltype(mfp);
+    new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
+    lua_pushcclosure_x(L, &invoke_const_member_function<F, T, 2>, debugname, 2);
+}
+
+template <class T, class U, class ReturnType, class... Params>
+void push_member_function_reflect(lua_State* L, ReturnType (U::*mfp)(Params...) const noexcept, const char* debugname)
+{
+    static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
+    using F = decltype(mfp);
+    new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
+    lua_pushcclosure_x(L, &invoke_const_member_function<F, T, 2>, debugname, 2);
+}
+
+// Callable object / lambda (reflect)
+template <class T, class F, class = std::enable_if<
+    is_callable_v<F> &&
+        std::is_object_v<F> &&
+        !std::is_pointer_v<F> &&
+        !std::is_member_function_pointer_v<F>>>
+void push_member_function_reflect(lua_State* L, F&& f, const char* debugname)
+{
+    static_assert(std::is_same_v<T, remove_cvref_t<std::remove_pointer_t<function_argument_or_void_t<0, F>>>>);
+    lua_newuserdata_aligned<F>(L, std::forward<F>(f));
+    lua_pushcclosure_x(L, &invoke_proxy_functor<F, 2>, debugname, 2);
+}
+
 //=================================================================================================
 /**
  * @brief
@@ -2610,16 +2768,30 @@ struct constructor
 {
     static T* construct(const Args& args)
     {
-        auto alloc = [](auto&&... args) { return new T(std::forward<decltype(args)>(args)...); };
-
-        return std::apply(alloc, args);
+        if constexpr (std::is_aggregate_v<T>)
+        {
+            auto alloc = [](auto&&... args) { return new T{std::forward<decltype(args)>(args)...}; };
+            return std::apply(alloc, args);
+        }
+        else
+        {
+            auto alloc = [](auto&&... args) { return new T(std::forward<decltype(args)>(args)...); };
+            return std::apply(alloc, args);
+        }
     }
 
     static T* construct(void* ptr, const Args& args)
     {
-        auto alloc = [ptr](auto&&... args) { return new (ptr) T(std::forward<decltype(args)>(args)...); };
-
-        return std::apply(alloc, args);
+        if constexpr (std::is_aggregate_v<T>)
+        {
+            auto alloc = [ptr](auto&&... args) { return new (ptr) T{std::forward<decltype(args)>(args)...}; };
+            return std::apply(alloc, args);
+        }
+        else
+        {
+            auto alloc = [ptr](auto&&... args) { return new (ptr) T(std::forward<decltype(args)>(args)...); };
+            return std::apply(alloc, args);
+        }
     }
 };
 
diff --git a/Source/LuaBridge/detail/FunctionHints.h b/Source/LuaBridge/detail/FunctionHints.h
index 98c15510..1ab29d2e 100644
--- a/Source/LuaBridge/detail/FunctionHints.h
+++ b/Source/LuaBridge/detail/FunctionHints.h
@@ -145,28 +145,30 @@ template <class F>
  * lua_State* parameters are filtered out (they are auto-injected by LuaBridge, not
  * visible from Lua).
  */
+template <class Tuple, std::size_t... I>
+void reflect_param_type_names_impl(std::vector<std::string>& result, std::index_sequence<I...>)
+{
+    // Fold expression over comma operator (C++17): invoke a lambda for each index
+    (
+        [&]()
+        {
+            using ParamT = std::tuple_element_t<I, Tuple>;
+
+            constexpr bool isLuaState =
+                std::is_pointer_v<ParamT> &&
+                std::is_same_v<std::remove_const_t<std::remove_pointer_t<ParamT>>, lua_State>;
+
+            if constexpr (!isLuaState)
+                result.push_back(std::string(typeName<std::remove_cvref_t<ParamT>>()));
+        }(),
+        ...);
+}
+
 template <class Tuple>
 [[nodiscard]] std::vector<std::string> reflect_param_type_names()
 {
     std::vector<std::string> result;
-
-    [&]<std::size_t... I>(std::index_sequence<I...>)
-    {
-        (
-            [&]
-            {
-                using ParamT = std::tuple_element_t<I, Tuple>;
-
-                constexpr bool isLuaState =
-                    std::is_pointer_v<ParamT> &&
-                    std::is_same_v<std::remove_const_t<std::remove_pointer_t<ParamT>>, lua_State>;
-
-                if constexpr (!isLuaState)
-                    result.push_back(std::string(typeName<std::remove_cvref_t<ParamT>>()));
-            }(),
-            ...);
-    }(std::make_index_sequence<std::tuple_size_v<Tuple>>{});
-
+    reflect_param_type_names_impl<Tuple>(result, std::make_index_sequence<std::tuple_size_v<Tuple>>{});
     return result;
 }
 
diff --git a/Source/LuaBridge/detail/Namespace.h b/Source/LuaBridge/detail/Namespace.h
index e0271c66..0039f3e4 100644
--- a/Source/LuaBridge/detail/Namespace.h
+++ b/Source/LuaBridge/detail/Namespace.h
@@ -745,35 +745,32 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                // Wrap in 1-entry OverloadSet so metadata is accessible at runtime.
+#if LUABRIDGE_ENABLE_REFLECT
+                // Embed 1-entry OverloadSet as upvalue[1] of the actual function closure so
+                // metadata is accessible at runtime without a wrapper.
                 ([&]
                 {
-                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
-                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
-
-                    detail::OverloadEntry entry;
                     if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
                     {
+                        auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                        auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                        detail::OverloadEntry entry;
                         using ArgsPack = detail::function_arguments_t<Functions>;
-                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
-                        entry.checker = &detail::overload_type_checker<ArgsPack>;
-                        entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                        entry.arity = -1;
+                        entry.checker = nullptr;
+                        entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                         entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         if constexpr (detail::is_function_with_hints_v<Functions>)
                             entry.paramHints = functions.hints;
+                        overload_set->entries.push_back(std::move(entry));
+
+                        detail::push_function_reflect(L, detail::get_underlying(std::move(functions)), name);
                     }
                     else
                     {
-                        entry.arity = -1;
-                        entry.checker = nullptr;
+                        detail::push_function(L, detail::get_underlying(std::move(functions)), name);
                     }
-                    overload_set->entries.push_back(std::move(entry));
-
-                    lua_createtable(L, 1, 0);
-                    detail::push_function(L, detail::get_underlying(std::move(functions)), name);
-                    lua_rawseti(L, -2, 1);
-                    lua_pushcclosure_x(L, &detail::try_overload_functions<false>, name, 2);
 
                 } (), ...);
 #else
@@ -803,8 +800,8 @@ class Namespace : public detail::Registrar
                         using ArgsPack = detail::function_arguments_t<Functions>;
                         entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                         entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                        entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                        entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                         entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         if constexpr (detail::is_function_with_hints_v<Functions>)
                             entry.paramHints = functions.hints;
@@ -973,47 +970,47 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                // When reflection is enabled, wrap single functions in a 1-entry OverloadSet so
-                // metadata (return type, param types, hints) is uniformly accessible at runtime.
+#if LUABRIDGE_ENABLE_REFLECT
+                // Embed 1-entry OverloadSet as upvalue[1] of the actual function closure so
+                // metadata is accessible at runtime without a wrapper (avoiding C-to-C call chains
+                // that break luaL_argerror function-name resolution).
                 ([&]
                 {
-                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
-                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
-
-                    detail::OverloadEntry entry;
                     if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
                     {
+                        auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                        auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                        detail::OverloadEntry entry;
                         if constexpr (detail::is_proxy_member_function_v<T, Functions>)
                         {
                             using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
-                            entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
-                            entry.checker = &detail::overload_type_checker<ArgsPack>;
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.arity = -1;
+                            entry.checker = nullptr;
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         }
                         else
                         {
                             using ArgsPack = detail::function_arguments_t<Functions>;
-                            entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
-                            entry.checker = &detail::overload_type_checker<ArgsPack>;
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                            entry.arity = -1;
+                            entry.checker = nullptr;
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         }
                         if constexpr (detail::is_function_with_hints_v<Functions>)
                             entry.paramHints = functions.hints;
+                        overload_set->entries.push_back(std::move(entry));
+
+                        // OverloadSet is now at stack top (upvalue[1]).
+                        // push_member_function_reflect pushes function data as upvalue[2].
+                        detail::push_member_function_reflect<T>(L, detail::get_underlying(std::move(functions)), name);
                     }
                     else
                     {
-                        entry.arity = -1;
-                        entry.checker = nullptr;
+                        // Bare cfunction: no type metadata to embed; register directly.
+                        detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
                     }
-                    overload_set->entries.push_back(std::move(entry));
-
-                    lua_createtable(L, 1, 0);
-                    detail::push_member_function<T>(L, detail::get_underlying(std::move(functions)), name);
-                    lua_rawseti(L, -2, 1);
-                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, name, 2);
 
                 } (), ...);
 #else
@@ -1060,8 +1057,8 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                             if constexpr (detail::is_function_with_hints_v<Functions>)
                                 entry.paramHints = functions.hints;
@@ -1072,8 +1069,8 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::function_arguments_t<Functions>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                             if constexpr (detail::is_function_with_hints_v<Functions>)
                                 entry.paramHints = functions.hints;
@@ -1129,8 +1126,8 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<Functions>>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                             if constexpr (detail::is_function_with_hints_v<Functions>)
                                 entry.paramHints = functions.hints;
@@ -1141,8 +1138,8 @@ class Namespace : public detail::Registrar
                             using ArgsPack = detail::function_arguments_t<Functions>;
                             entry.arity = static_cast<int>(detail::member_function_arity_excluding_v<T, Functions, lua_State*>);
                             entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                            entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                            entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                             entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                             if constexpr (detail::is_function_with_hints_v<Functions>)
                                 entry.paramHints = functions.hints;
@@ -1266,8 +1263,10 @@ class Namespace : public detail::Registrar
 
             if constexpr (sizeof...(Functions) == 1)
             {
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                // Wrap in 1-entry OverloadSet so constructor metadata is accessible at runtime.
+#if LUABRIDGE_ENABLE_REFLECT
+                // Embed 1-entry OverloadSet as upvalue[1] of the constructor closure.
+                // constructor_placement_proxy uses no upvalues internally, so upvalue[1]
+                // is only there for getOverloadInfos() to read metadata.
                 ([&]
                 {
                     using ArgsPack = detail::function_arguments_t<Functions>;
@@ -1276,16 +1275,14 @@ class Namespace : public detail::Registrar
                     auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
 
                     detail::OverloadEntry entry;
-                    entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
-                    entry.checker = &detail::overload_type_checker<ArgsPack>;
+                    entry.arity = -1;
+                    entry.checker = nullptr;
                     entry.returnType = std::string(detail::typeName<T>());
                     entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                     overload_set->entries.push_back(std::move(entry));
 
-                    lua_createtable(L, 1, 0);
-                    lua_pushcclosure_x(L, &detail::constructor_placement_proxy<T, ArgsPack>, className, 0);
-                    lua_rawseti(L, -2, 1);
-                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, className, 2);
+                    // OverloadSet is at stack top (upvalue[1]); constructor_placement_proxy ignores it.
+                    lua_pushcclosure_x(L, &detail::constructor_placement_proxy<T, ArgsPack>, className, 1);
 
                 } (), ...);
 #else
@@ -1308,7 +1305,7 @@ class Namespace : public detail::Registrar
                     detail::OverloadEntry entry;
                     entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                     entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
                     entry.returnType = std::string(detail::typeName<T>());
                     entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
 #endif
@@ -1361,29 +1358,26 @@ class Namespace : public detail::Registrar
                     using InnerF = detail::unwrap_fn_type_t<Functions>;
                     using F = detail::constructor_forwarder<T, InnerF>;
 
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                    // Wrap in 1-entry OverloadSet so constructor metadata is accessible at runtime.
-                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
-                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
-
+#if LUABRIDGE_ENABLE_REFLECT
+                    // Embed 1-entry OverloadSet as upvalue[1] of the constructor closure so
+                    // metadata is accessible at runtime without a wrapper.
                     {
+                        auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                        auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
                         // skip void* first arg (placement new destination, not a Lua argument)
                         using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<InnerF>>;
                         detail::OverloadEntry entry;
-                        entry.arity = static_cast<int>(detail::function_arity_excluding_v<InnerF, lua_State*>) - 1;
-                        entry.checker = &detail::overload_type_checker<ArgsPack>;
+                        entry.arity = -1;
+                        entry.checker = nullptr;
                         entry.returnType = std::string(detail::typeName<T>());
                         entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         if constexpr (detail::is_function_with_hints_v<Functions>)
                             entry.paramHints = functions.hints;
                         overload_set->entries.push_back(std::move(entry));
                     }
-
-                    lua_createtable(L, 1, 0);
-                    lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions))));
-                    lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1);
-                    lua_rawseti(L, -2, 1);
-                    lua_pushcclosure_x(L, &detail::try_overload_functions<true>, className, 2);
+                    // OverloadSet is now at stack top (upvalue[1]).
+                    lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions)))); // upvalue[2]
+                    lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F, 2>, className, 2);
 #else
                     lua_newuserdata_aligned<F>(L, F(detail::get_underlying(std::move(functions)))); // Stack: co, cl, st, upvalue
                     lua_pushcclosure_x(L, &detail::invoke_proxy_constructor<F>, className, 1); // Stack: co, cl, st, function
@@ -1412,7 +1406,7 @@ class Namespace : public detail::Registrar
                         using ArgsPack = detail::remove_first_type_t<detail::function_arguments_t<InnerF>>;
                         entry.arity = static_cast<int>(detail::function_arity_excluding_v<InnerF, lua_State*>) - 1;
                         entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
+#if LUABRIDGE_ENABLE_REFLECT
                         entry.returnType = std::string(detail::typeName<T>());
                         entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                         if constexpr (detail::is_function_with_hints_v<Functions>)
@@ -2092,35 +2086,36 @@ class Namespace : public detail::Registrar
 
         if constexpr (sizeof...(Functions) == 1)
         {
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-            // Wrap in 1-entry OverloadSet so metadata is accessible at runtime.
+#if LUABRIDGE_ENABLE_REFLECT
+            // Embed 1-entry OverloadSet as upvalue[1] of the actual function closure so that
+            // metadata is accessible at runtime without a wrapper (avoiding C-to-C call chains
+            // that break luaL_argerror function-name resolution).
             ([&]
             {
-                auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
-                auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
-
-                detail::OverloadEntry entry;
                 if constexpr (!detail::is_any_cfunction_pointer_v<Functions>)
                 {
+                    auto* overload_set_unaligned = lua_newuserdata_aligned<detail::OverloadSet>(L);
+                    auto* overload_set = align<detail::OverloadSet>(overload_set_unaligned);
+
+                    detail::OverloadEntry entry;
                     using ArgsPack = detail::function_arguments_t<Functions>;
-                    entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
-                    entry.checker = &detail::overload_type_checker<ArgsPack>;
-                    entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+                    entry.arity = -1; // single overload: arity check disabled
+                    entry.checker = nullptr; // single overload: no type dispatch needed
+                    entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                     entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                     if constexpr (detail::is_function_with_hints_v<Functions>)
                         entry.paramHints = functions.hints;
+                    overload_set->entries.push_back(std::move(entry));
+
+                    // OverloadSet is now at stack top (upvalue[1]).
+                    // push_function_reflect pushes function data as upvalue[2] and creates the closure.
+                    detail::push_function_reflect(L, detail::get_underlying(std::move(functions)), name);
                 }
                 else
                 {
-                    entry.arity = -1;
-                    entry.checker = nullptr;
+                    // Bare cfunction: no type metadata to embed; register directly.
+                    detail::push_function(L, detail::get_underlying(std::move(functions)), name);
                 }
-                overload_set->entries.push_back(std::move(entry));
-
-                lua_createtable(L, 1, 0);
-                detail::push_function(L, detail::get_underlying(std::move(functions)), name);
-                lua_rawseti(L, -2, 1);
-                lua_pushcclosure_x(L, &detail::try_overload_functions<false>, name, 2);
 
             } (), ...);
 #else
@@ -2150,8 +2145,8 @@ class Namespace : public detail::Registrar
                     using ArgsPack = detail::function_arguments_t<Functions>;
                     entry.arity = static_cast<int>(detail::function_arity_excluding_v<Functions, lua_State*>);
                     entry.checker = &detail::overload_type_checker<ArgsPack>;
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-                    entry.returnType = std::string(detail::typeName<detail::function_result_t<Functions>>());
+#if LUABRIDGE_ENABLE_REFLECT
+                    entry.returnType = std::string(detail::typeName<std::remove_cvref_t<detail::function_result_t<Functions>>>());
                     entry.paramTypes = detail::reflect_param_type_names<ArgsPack>();
                     if constexpr (detail::is_function_with_hints_v<Functions>)
                         entry.paramHints = functions.hints;
diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index 42fa651e..3650aa56 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -71,7 +71,14 @@ source_group ("Source Files" FILES ${LUABRIDGE_TEST_SOURCE_FILES})
 
 # ====================================================== Lua C
 
-set (LUABRIDGE_LUA_C_DEFINES "LUABRIDGE_SAFE_LUA_C_EXCEPTION_HANDLING=1")
+set (LUABRIDGE_LUA_DEFAULT_DEFINES)
+
+set (LUABRIDGE_LUA_CPP_DEFINES
+  ${LUABRIDGE_LUA_DEFAULT_DEFINES})
+
+set (LUABRIDGE_LUA_C_DEFINES
+  ${LUABRIDGE_LUA_DEFAULT_DEFINES}
+  -DLUABRIDGE_SAFE_LUA_C_EXCEPTION_HANDLING=1)
 
 # ====================================================== Lua 5.1
 
@@ -199,63 +206,45 @@ function (setup_target_for_coverage TARGET_NAME SOURCE_LOCATION SOURCE_PACKAGE)
 endfunction ()
 
 function (setup_coverage_single_target)
+  set (LUABRIDGE_COVERAGE_TARGETS)
+
+  foreach (LUA_VERSION_SUFFIX IN ITEMS 51 52 53 54 55)
+    foreach (TEST_VARIANT IN ITEMS "" "Noexcept" "Reflect" "ReflectNoexcept" "LuaC" "LuaCNoexcept")
+      list (APPEND LUABRIDGE_COVERAGE_TARGETS "LuaBridgeTests${LUA_VERSION_SUFFIX}${TEST_VARIANT}")
+    endforeach ()
+  endforeach ()
+
+  list (APPEND LUABRIDGE_COVERAGE_TARGETS
+    LuaBridgeTestsLuau
+    LuaBridgeTestsLuauReflect)
+
+  if (NOT EMSCRIPTEN)
+    list (APPEND LUABRIDGE_COVERAGE_TARGETS
+      LuaBridgeTestsLuaJIT
+      LuaBridgeTestsLuaJITNoexcept
+      LuaBridgeTestsLuaJITReflect
+      LuaBridgeTestsLuaJITReflectNoexcept
+      LuaBridgeTestsRavi
+      LuaBridgeTestsRaviReflect)
+  endif ()
+
+  set (LUABRIDGE_COVERAGE_INFO_FILES)
+  set (LUABRIDGE_COVERAGE_MERGE_ARGS)
+  foreach (COVERAGE_TARGET IN LISTS LUABRIDGE_COVERAGE_TARGETS)
+    list (APPEND LUABRIDGE_COVERAGE_INFO_FILES "coverage/${COVERAGE_TARGET}.info")
+    list (APPEND LUABRIDGE_COVERAGE_MERGE_ARGS -a "coverage/${COVERAGE_TARGET}.info")
+  endforeach ()
+
   add_custom_target (LuaBridgeTestsCoverage
     COMMAND ${CMAKE_COMMAND} -E make_directory coverage_html
     COMMAND ${CMAKE_COMMAND} -E rm -Rf coverage_html/*
     COMMAND ${CMAKE_COMMAND} -E rm -f coverage/Merged.info
     COMMAND ${LCOV_EXECUTABLE}
-      -a "coverage/LuaBridgeTests51.info"
-      -a "coverage/LuaBridgeTests51LuaC.info"
-      -a "coverage/LuaBridgeTests51Noexcept.info"
-      -a "coverage/LuaBridgeTests51LuaCNoexcept.info"
-      -a "coverage/LuaBridgeTests52.info"
-      -a "coverage/LuaBridgeTests52LuaC.info"
-      -a "coverage/LuaBridgeTests52Noexcept.info"
-      -a "coverage/LuaBridgeTests52LuaCNoexcept.info"
-      -a "coverage/LuaBridgeTests53.info"
-      -a "coverage/LuaBridgeTests53LuaC.info"
-      -a "coverage/LuaBridgeTests53Noexcept.info"
-      -a "coverage/LuaBridgeTests53LuaCNoexcept.info"
-      -a "coverage/LuaBridgeTests54.info"
-      -a "coverage/LuaBridgeTests54LuaC.info"
-      -a "coverage/LuaBridgeTests54Noexcept.info"
-      -a "coverage/LuaBridgeTests54LuaCNoexcept.info"
-      -a "coverage/LuaBridgeTests55.info"
-      -a "coverage/LuaBridgeTests55LuaC.info"
-      -a "coverage/LuaBridgeTests55Noexcept.info"
-      -a "coverage/LuaBridgeTests55LuaCNoexcept.info"
-      -a "coverage/LuaBridgeTestsLuaJIT.info"
-      -a "coverage/LuaBridgeTestsLuaJITNoexcept.info"
-      -a "coverage/LuaBridgeTestsLuau.info"
-      -a "coverage/LuaBridgeTestsRavi.info"
+      ${LUABRIDGE_COVERAGE_MERGE_ARGS}
       -o "coverage/Merged.info"
     COMMAND ${GENHTML_EXECUTABLE}
       --rc branch_coverage=1 "coverage/Merged.info" -o "coverage_html"
-    DEPENDS
-      "coverage/LuaBridgeTests51.info"
-      "coverage/LuaBridgeTests51LuaC.info"
-      "coverage/LuaBridgeTests51Noexcept.info"
-      "coverage/LuaBridgeTests51LuaCNoexcept.info"
-      "coverage/LuaBridgeTests52.info"
-      "coverage/LuaBridgeTests52LuaC.info"
-      "coverage/LuaBridgeTests52Noexcept.info"
-      "coverage/LuaBridgeTests52LuaCNoexcept.info"
-      "coverage/LuaBridgeTests53.info"
-      "coverage/LuaBridgeTests53LuaC.info"
-      "coverage/LuaBridgeTests53Noexcept.info"
-      "coverage/LuaBridgeTests53LuaCNoexcept.info"
-      "coverage/LuaBridgeTests54.info"
-      "coverage/LuaBridgeTests54LuaC.info"
-      "coverage/LuaBridgeTests54Noexcept.info"
-      "coverage/LuaBridgeTests54LuaCNoexcept.info"
-      "coverage/LuaBridgeTests55.info"
-      "coverage/LuaBridgeTests55LuaC.info"
-      "coverage/LuaBridgeTests55Noexcept.info"
-      "coverage/LuaBridgeTests55LuaCNoexcept.info"
-      "coverage/LuaBridgeTestsLuaJIT.info"
-      "coverage/LuaBridgeTestsLuaJITNoexcept.info"
-      "coverage/LuaBridgeTestsLuau.info"
-      "coverage/LuaBridgeTestsRavi.info"
+    DEPENDS ${LUABRIDGE_COVERAGE_INFO_FILES}
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
     VERBATIM)
 
@@ -286,7 +275,6 @@ macro (add_test_app LUABRIDGE_TEST_NAME LUA_VERSION LUABRIDGE_TEST_LUA_LIBRARY_F
 
     target_compile_definitions (${LUABRIDGE_TESTLIB_NAME} PRIVATE
       LUABRIDGE_TEST_SHARED_EXPORT=1
-      LUABRIDGE_ENABLE_REFLECT=1
       ${LUABRIDGE_DEFINES})
 
     target_include_directories (${LUABRIDGE_TESTLIB_NAME} PRIVATE
@@ -350,16 +338,18 @@ macro (add_test_app LUABRIDGE_TEST_NAME LUA_VERSION LUABRIDGE_TEST_LUA_LIBRARY_F
     Source)
 
   if (${LUA_VERSION} STREQUAL "LUAU")
-    target_include_directories (${LUABRIDGE_TEST_NAME} PRIVATE "${LUABRIDGE_LUAU_LOCATION}/VM/include")
-    target_include_directories (${LUABRIDGE_TEST_NAME} PRIVATE "${LUABRIDGE_LUAU_LOCATION}/Ast/include")
-    target_include_directories (${LUABRIDGE_TEST_NAME} PRIVATE "${LUABRIDGE_LUAU_LOCATION}/Compiler/include")
-    target_include_directories (${LUABRIDGE_TEST_NAME} PRIVATE "${LUABRIDGE_LUAU_LOCATION}/Common/include")
+    target_include_directories (${LUABRIDGE_TEST_NAME} PRIVATE
+      "${LUABRIDGE_LUAU_LOCATION}/VM/include"
+      "${LUABRIDGE_LUAU_LOCATION}/Ast/include"
+      "${LUABRIDGE_LUAU_LOCATION}/Compiler/include"
+      "${LUABRIDGE_LUAU_LOCATION}/Common/include")
     target_compile_definitions (${LUABRIDGE_TEST_NAME} PRIVATE LUABRIDGE_TEST_LUAU=1)
     if (LUABRIDGE_BUILD_SHARED_TESTS)
-      target_include_directories (${LUABRIDGE_TESTLIB_NAME} PRIVATE "${LUABRIDGE_LUAU_LOCATION}/VM/include")
-      target_include_directories (${LUABRIDGE_TESTLIB_NAME} PRIVATE "${LUABRIDGE_LUAU_LOCATION}/Ast/include")
-      target_include_directories (${LUABRIDGE_TESTLIB_NAME} PRIVATE "${LUABRIDGE_LUAU_LOCATION}/Compiler/include")
-      target_include_directories (${LUABRIDGE_TESTLIB_NAME} PRIVATE "${LUABRIDGE_LUAU_LOCATION}/Common/include")
+      target_include_directories (${LUABRIDGE_TESTLIB_NAME} PRIVATE
+        "${LUABRIDGE_LUAU_LOCATION}/VM/include"
+        "${LUABRIDGE_LUAU_LOCATION}/Ast/include"
+        "${LUABRIDGE_LUAU_LOCATION}/Compiler/include"
+        "${LUABRIDGE_LUAU_LOCATION}/Common/include")
       target_compile_definitions (${LUABRIDGE_TESTLIB_NAME} PRIVATE LUABRIDGE_TEST_LUAU=1)
     endif ()
   elseif (${LUA_VERSION} STREQUAL "LUAJIT")
@@ -388,13 +378,11 @@ macro (add_test_app LUABRIDGE_TEST_NAME LUA_VERSION LUABRIDGE_TEST_LUA_LIBRARY_F
       set (LUABRIDGE_TEST_SHARED_LIBRARY "lib${LUABRIDGE_TESTLIB_NAME}.so")
     endif ()
     target_compile_definitions (${LUABRIDGE_TEST_NAME} PRIVATE
-      LUABRIDGE_ENABLE_REFLECT=1
       LUABRIDGE_TEST_SHARED_LIBRARY="${LUABRIDGE_TEST_SHARED_LIBRARY}"
-      LUABRIDGE_TEST_SHARED_EXPORT=0)
+      LUABRIDGE_TEST_SHARED_EXPORT=0
+      ${LUABRIDGE_DEFINES})
   endif ()
 
-  target_compile_definitions (${LUABRIDGE_TEST_NAME} PRIVATE LUABRIDGE_ENABLE_REFLECT=1)
-
   if (NOT ${LUABRIDGE_EXCEPTIONS})
     target_compile_definitions (${LUABRIDGE_TEST_NAME} PRIVATE LUA_USE_LONGJMP=1)
     if (APPLE)
@@ -438,43 +426,57 @@ endmacro (add_test_app)
 
 # ====================================================== Real Unit Tests
 
-add_test_app (LuaBridgeTests51 501 "${LUABRIDGE_TEST_LUA51_FILES}" 1 "" "")
+add_test_app (LuaBridgeTests51 501 "${LUABRIDGE_TEST_LUA51_FILES}" 1 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests51Noexcept 501 "${LUABRIDGE_TEST_LUA51_FILES}" 0 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests51Reflect 501 "${LUABRIDGE_TEST_LUA51_FILES}" 1 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests51ReflectNoexcept 501 "${LUABRIDGE_TEST_LUA51_FILES}" 0 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
 add_test_app (LuaBridgeTests51LuaC 501 "${LUABRIDGE_TEST_LUA51_C_FILES}" 1 "${LUABRIDGE_LUA_C_DEFINES}" "")
-add_test_app (LuaBridgeTests51Noexcept 501 "${LUABRIDGE_TEST_LUA51_FILES}" 0 "" "")
 add_test_app (LuaBridgeTests51LuaCNoexcept 501 "${LUABRIDGE_TEST_LUA51_C_FILES}" 0 "${LUABRIDGE_LUA_C_DEFINES}" "")
 
-add_test_app (LuaBridgeTests52 502 "${LUABRIDGE_TEST_LUA52_FILES}" 1 "" "")
+add_test_app (LuaBridgeTests52 502 "${LUABRIDGE_TEST_LUA52_FILES}" 1 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests52Noexcept 502 "${LUABRIDGE_TEST_LUA52_FILES}" 0 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests52Reflect 502 "${LUABRIDGE_TEST_LUA52_FILES}" 1 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests52ReflectNoexcept 502 "${LUABRIDGE_TEST_LUA52_FILES}" 0 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
 add_test_app (LuaBridgeTests52LuaC 502 "${LUABRIDGE_TEST_LUA52_C_FILES}" 1 "${LUABRIDGE_LUA_C_DEFINES}" "")
-add_test_app (LuaBridgeTests52Noexcept 502 "${LUABRIDGE_TEST_LUA52_FILES}" 0 "" "")
 add_test_app (LuaBridgeTests52LuaCNoexcept 502 "${LUABRIDGE_TEST_LUA52_C_FILES}" 0 "${LUABRIDGE_LUA_C_DEFINES}" "")
 
-add_test_app (LuaBridgeTests53 503 "${LUABRIDGE_TEST_LUA53_FILES}" 1 "" "")
+add_test_app (LuaBridgeTests53 503 "${LUABRIDGE_TEST_LUA53_FILES}" 1 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests53Noexcept 503 "${LUABRIDGE_TEST_LUA53_FILES}" 0 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests53Reflect 503 "${LUABRIDGE_TEST_LUA53_FILES}" 1 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests53ReflectNoexcept 503 "${LUABRIDGE_TEST_LUA53_FILES}" 0 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
 add_test_app (LuaBridgeTests53LuaC 503 "${LUABRIDGE_TEST_LUA53_C_FILES}" 1 "${LUABRIDGE_LUA_C_DEFINES}" "")
-add_test_app (LuaBridgeTests53Noexcept 503 "${LUABRIDGE_TEST_LUA53_FILES}" 0 "" "")
 add_test_app (LuaBridgeTests53LuaCNoexcept 503 "${LUABRIDGE_TEST_LUA53_C_FILES}" 0 "${LUABRIDGE_LUA_C_DEFINES}" "")
 
-add_test_app (LuaBridgeTests54 504 "${LUABRIDGE_TEST_LUA54_FILES}" 1 "" "")
+add_test_app (LuaBridgeTests54 504 "${LUABRIDGE_TEST_LUA54_FILES}" 1 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests54Noexcept 504 "${LUABRIDGE_TEST_LUA54_FILES}" 0 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests54Reflect 504 "${LUABRIDGE_TEST_LUA54_FILES}" 1 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests54ReflectNoexcept 504 "${LUABRIDGE_TEST_LUA54_FILES}" 0 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
 add_test_app (LuaBridgeTests54LuaC 504 "${LUABRIDGE_TEST_LUA54_C_FILES}" 1 "${LUABRIDGE_LUA_C_DEFINES}" "")
-add_test_app (LuaBridgeTests54Noexcept 504 "${LUABRIDGE_TEST_LUA54_FILES}" 0 "" "")
 add_test_app (LuaBridgeTests54LuaCNoexcept 504 "${LUABRIDGE_TEST_LUA54_C_FILES}" 0 "${LUABRIDGE_LUA_C_DEFINES}" "")
 
-add_test_app (LuaBridgeTests55 505 "${LUABRIDGE_TEST_LUA55_FILES}" 1 "" "")
+add_test_app (LuaBridgeTests55 505 "${LUABRIDGE_TEST_LUA55_FILES}" 1 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests55Noexcept 505 "${LUABRIDGE_TEST_LUA55_FILES}" 0 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests55Reflect 505 "${LUABRIDGE_TEST_LUA55_FILES}" 1 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTests55ReflectNoexcept 505 "${LUABRIDGE_TEST_LUA55_FILES}" 0 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
 add_test_app (LuaBridgeTests55LuaC 505 "${LUABRIDGE_TEST_LUA55_C_FILES}" 1 "${LUABRIDGE_LUA_C_DEFINES}" "")
-add_test_app (LuaBridgeTests55Noexcept 505 "${LUABRIDGE_TEST_LUA55_FILES}" 0 "" "")
 add_test_app (LuaBridgeTests55LuaCNoexcept 505 "${LUABRIDGE_TEST_LUA55_C_FILES}" 0 "${LUABRIDGE_LUA_C_DEFINES}" "")
 
-if (NOT EMSCRIPTEN)
-  add_test_app (LuaBridgeTestsLuaJIT "LUAJIT" "${LUABRIDGE_TEST_LUAJIT_FILES}" 1 "" "liblua-static")
-  add_test_app (LuaBridgeTestsLuaJITNoexcept "LUAJIT" "${LUABRIDGE_TEST_LUAJIT_FILES}" 0 "" "liblua-static")
-endif ()
-
-add_test_app (LuaBridgeTestsLuau "LUAU" "${LUABRIDGE_TEST_LUAU_FILES}" 1 "" "")
-#add_test_app (LuaBridgeTestsLuauNoexcept "LUAU" "${LUABRIDGE_TEST_LUAU_FILES}" 0 "" "")
+add_test_app (LuaBridgeTestsLuau "LUAU" "${LUABRIDGE_TEST_LUAU_FILES}" 1 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+#add_test_app (LuaBridgeTestsLuauNoexcept "LUAU" "${LUABRIDGE_TEST_LUAU_FILES}" 0 "${LUABRIDGE_LUA_CPP_DEFINES}" "")
+add_test_app (LuaBridgeTestsLuauReflect "LUAU" "${LUABRIDGE_TEST_LUAU_FILES}" 1 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
+#add_test_app (LuaBridgeTestsLuauReflectNoexcept "LUAU" "${LUABRIDGE_TEST_LUAU_FILES}" 0 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "")
 
 if (NOT EMSCRIPTEN)
+  add_test_app (LuaBridgeTestsLuaJIT "LUAJIT" "${LUABRIDGE_TEST_LUAJIT_FILES}" 1 "${LUABRIDGE_LUA_CPP_DEFINES}" "liblua-static")
+  add_test_app (LuaBridgeTestsLuaJITNoexcept "LUAJIT" "${LUABRIDGE_TEST_LUAJIT_FILES}" 0 "${LUABRIDGE_LUA_CPP_DEFINES}" "liblua-static")
+  add_test_app (LuaBridgeTestsLuaJITReflect "LUAJIT" "${LUABRIDGE_TEST_LUAJIT_FILES}" 1 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "liblua-static")
+  add_test_app (LuaBridgeTestsLuaJITReflectNoexcept "LUAJIT" "${LUABRIDGE_TEST_LUAJIT_FILES}" 0 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_CPP_DEFINES}" "liblua-static")
+
   add_test_app (LuaBridgeTestsRavi "RAVI" "${LUABRIDGE_TEST_RAVI_FILES}" 1 "${LUABRIDGE_LUA_C_DEFINES}" "libravi")
+  #add_test_app (LuaBridgeTestsRaviNoexcept "RAVI" "${LUABRIDGE_TEST_RAVI_FILES}" 0 "${LUABRIDGE_LUA_C_DEFINES}" "libravi")
+  add_test_app (LuaBridgeTestsRaviReflect "RAVI" "${LUABRIDGE_TEST_RAVI_FILES}" 1 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_C_DEFINES}" "libravi")
+  #add_test_app (LuaBridgeTestsRaviReflectNoexcept "RAVI" "${LUABRIDGE_TEST_RAVI_FILES}" 0 "-DLUABRIDGE_ENABLE_REFLECT=1;${LUABRIDGE_LUA_C_DEFINES}" "libravi")
 endif ()
-#add_test_app (LuaBridgeTestsRaviNoexcept "RAVI" "${LUABRIDGE_TEST_RAVI_FILES}" 0 "" "libravi")
 
 if (LUABRIDGE_COVERAGE)
   setup_coverage_single_target ()
diff --git a/Tests/Source/InspectTests.cpp b/Tests/Source/InspectTests.cpp
index 7d4ac746..54f22674 100644
--- a/Tests/Source/InspectTests.cpp
+++ b/Tests/Source/InspectTests.cpp
@@ -5,6 +5,7 @@
 #include "TestBase.h"
 
 #include "LuaBridge/LuaBridge.h"
+#include "LuaBridge/Inspect.h"
 
 #include <algorithm>
 #include <sstream>
@@ -333,7 +334,7 @@ TEST_F(InspectTests, LuaTableVisitorProducesTable)
 
     lua_getfield(L, -1, "classes");
     EXPECT_TRUE(lua_istable(L, -1));
-    EXPECT_EQ(1, (int)lua_rawlen(L, -1));
+    EXPECT_EQ(1, luabridge::get_length(L, -1));
     lua_pop(L, 1);
 
     lua_pop(L, 1); // pop result table
@@ -467,12 +468,10 @@ TEST_F(InspectTests, WithHintsIsAcceptedByAddFunction)
     struct Actor { void attack(float /*damage*/) {} };
 
     // This test verifies that withHints compiles and the function is registered correctly.
-    EXPECT_NO_THROW(
-        luabridge::getGlobalNamespace(L)
-            .beginClass<Actor>("Actor")
-                .addFunction("attack", luabridge::withHints(&Actor::attack, "damage"))
-            .endClass()
-    );
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Actor>("Actor")
+            .addFunction("attack", luabridge::withHints(&Actor::attack, "damage"))
+        .endClass();
 
     // Verify the function is callable from Lua
     auto info = luabridge::inspect<Actor>(L);
@@ -485,14 +484,12 @@ TEST_F(InspectTests, WithHintsOverloadsCompile)
 {
     struct Shooter {};
 
-    EXPECT_NO_THROW(
-        luabridge::getGlobalNamespace(L)
-            .beginClass<Shooter>("Shooter")
-                .addFunction("fire",
-                    luabridge::withHints([](Shooter&, int /*count*/) {}, "count"),
-                    luabridge::withHints([](Shooter&, float /*angle*/, int /*count*/) {}, "angle", "count"))
-            .endClass()
-    );
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Shooter>("Shooter")
+            .addFunction("fire",
+                luabridge::withHints([](Shooter&, int /*count*/) {}, "count"),
+                luabridge::withHints([](Shooter&, float /*angle*/, int /*count*/) {}, "angle", "count"))
+        .endClass();
 
     auto info = luabridge::inspect<Shooter>(L);
     auto* m = findMember(info, "fire");
@@ -500,8 +497,7 @@ TEST_F(InspectTests, WithHintsOverloadsCompile)
     EXPECT_EQ(2u, m->overloads.size());
 }
 
-#if defined(LUABRIDGE_ENABLE_REFLECT)
-
+#if LUABRIDGE_ENABLE_REFLECT
 TEST_F(InspectTests, ReflectTypeInfoPopulated)
 {
     struct Enemy { void takeDamage(float /*amount*/, int /*count*/) {} };
@@ -530,7 +526,7 @@ TEST_F(InspectTests, ReflectTypeInfoPopulated)
 
 TEST_F(InspectTests, ReflectConstructorTypeInfo)
 {
-    struct Widget {};
+    struct Widget { int x; float y; };
 
     luabridge::getGlobalNamespace(L)
         .beginClass<Widget>("Widget")
@@ -561,5 +557,4 @@ TEST_F(InspectTests, ReflectFreeFunction)
     EXPECT_EQ("a", fn->overloads[0].params[0].hint);
     EXPECT_EQ("b", fn->overloads[0].params[1].hint);
 }
-
 #endif // LUABRIDGE_ENABLE_REFLECT

From 0c1de9d7adcc7db25541cf78ae926acd822eff19 Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Tue, 7 Apr 2026 17:50:26 +0200
Subject: [PATCH 03/14] Move tools and expand to more test runs

---
 .github/workflows/amalgamate.yml     |  6 +++---
 .github/workflows/build_linux.yml    | 22 +++++++++++++++++-----
 .github/workflows/build_macos.yml    | 22 +++++++++++++++++-----
 .github/workflows/build_windows.yml  | 18 ++++++++++++++----
 .github/workflows/coverage.yml       | 24 ++++++++++++++++++------
 amalgamate.py => Tools/amalgamate.py |  0
 cobertura.py => Tools/cobertura.py   |  0
 justfile                             |  3 +--
 8 files changed, 70 insertions(+), 25 deletions(-)
 rename amalgamate.py => Tools/amalgamate.py (100%)
 rename cobertura.py => Tools/cobertura.py (100%)

diff --git a/.github/workflows/amalgamate.yml b/.github/workflows/amalgamate.yml
index 8b87bd95..0043c811 100644
--- a/.github/workflows/amalgamate.yml
+++ b/.github/workflows/amalgamate.yml
@@ -6,8 +6,8 @@ on:
       - master
     paths:
       - "**/workflows/amalgamate.yml"
-      - "**/Source/**"
-      - "**/amalgamate.py"
+      - "**/Source/**/*.h"
+      - "**/Tools/amalgamate.py"
 
 jobs:
   run:
@@ -23,7 +23,7 @@ jobs:
           python-version: 3.9
 
       - name: Create amalgamation file
-        run: python amalgamate.py
+        run: python Tools/amalgamate.py
 
       - name: Commit changes
         uses: EndBug/add-and-commit@v10
diff --git a/.github/workflows/build_linux.yml b/.github/workflows/build_linux.yml
index 75b2aeec..ac051712 100644
--- a/.github/workflows/build_linux.yml
+++ b/.github/workflows/build_linux.yml
@@ -94,13 +94,17 @@ jobs:
       run: |
         cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
           LuaBridgeTestsLuaJIT \
-          LuaBridgeTestsLuaJITNoexcept
+          LuaBridgeTestsLuaJITReflect \
+          LuaBridgeTestsLuaJITNoexcept \
+          LuaBridgeTestsLuaJITReflectNoexcept
 
     - name: Test LuaJIT
       working-directory: ${{runner.workspace}}/build/Tests
       run: |
         ./LuaBridgeTestsLuaJIT
+        ./LuaBridgeTestsLuaJITReflect
         ./LuaBridgeTestsLuaJITNoexcept
+        ./LuaBridgeTestsLuaJITReflectNoexcept
 
   luau:
     runs-on: ubuntu-latest
@@ -122,11 +126,15 @@ jobs:
 
     - name: Build Luau
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target LuaBridgeTestsLuau
+      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+        LuaBridgeTestsLuau \
+        LuaBridgeTestsLuauReflect
 
     - name: Test Luau
       working-directory: ${{runner.workspace}}/build/Tests
-      run: ./LuaBridgeTestsLuau
+      run: |
+        ./LuaBridgeTestsLuau
+        ./LuaBridgeTestsLuauReflect
 
   ravi:
     runs-on: ubuntu-latest
@@ -148,8 +156,12 @@ jobs:
 
     - name: Build Ravi
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target LuaBridgeTestsRavi
+      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+        LuaBridgeTestsRavi \
+        LuaBridgeTestsRaviReflect
 
     - name: Test Ravi
       working-directory: ${{runner.workspace}}/build/Tests
-      run: ./LuaBridgeTestsRavi
+      run: |
+        ./LuaBridgeTestsRavi
+        ./LuaBridgeTestsRaviReflect
diff --git a/.github/workflows/build_macos.yml b/.github/workflows/build_macos.yml
index 9d0962f4..50cd8ce7 100644
--- a/.github/workflows/build_macos.yml
+++ b/.github/workflows/build_macos.yml
@@ -86,13 +86,17 @@ jobs:
       run: |
         cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
           LuaBridgeTestsLuaJIT \
-          LuaBridgeTestsLuaJITNoexcept
+          LuaBridgeTestsLuaJITReflect \
+          LuaBridgeTestsLuaJITNoexcept \
+          LuaBridgeTestsLuaJITReflectNoexcept
 
     - name: Test LuaJIT
       working-directory: ${{runner.workspace}}/build/Tests
       run: |
         ./LuaBridgeTestsLuaJIT
+        ./LuaBridgeTestsLuaJITReflect
         ./LuaBridgeTestsLuaJITNoexcept
+        ./LuaBridgeTestsLuaJITReflectNoexcept
 
   luau:
     runs-on: macos-latest
@@ -111,11 +115,15 @@ jobs:
 
     - name: Build Luau
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target LuaBridgeTestsLuau
+      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+        LuaBridgeTestsLuau \
+        LuaBridgeTestsLuauReflect
 
     - name: Test Luau
       working-directory: ${{runner.workspace}}/build/Tests
-      run: ./LuaBridgeTestsLuau
+      run: |
+        ./LuaBridgeTestsLuau
+        ./LuaBridgeTestsLuauReflect
 
   ravi:
     runs-on: macos-latest
@@ -134,8 +142,12 @@ jobs:
 
     - name: Build Ravi
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target LuaBridgeTestsRavi
+      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+        LuaBridgeTestsRavi \
+        LuaBridgeTestsRaviReflect
 
     - name: Test Ravi
       working-directory: ${{runner.workspace}}/build/Tests
-      run: ./LuaBridgeTestsRavi
+      run: |
+        ./LuaBridgeTestsRavi
+        ./LuaBridgeTestsRaviReflect
diff --git a/.github/workflows/build_windows.yml b/.github/workflows/build_windows.yml
index f7f3762e..3670bc0a 100644
--- a/.github/workflows/build_windows.yml
+++ b/.github/workflows/build_windows.yml
@@ -91,14 +91,18 @@ jobs:
       run: |
         cmake --build . --config $BUILD_TYPE --parallel 4 --target \
           LuaBridgeTestsLuaJIT \
-          LuaBridgeTestsLuaJITNoexcept
+          LuaBridgeTestsLuaJITReflect \
+          LuaBridgeTestsLuaJITNoexcept \
+          LuaBridgeTestsLuaJITReflectNoexcept
 
     - name: Test LuaJIT
       working-directory: ${{runner.workspace}}/build/Tests/Release
       shell: bash
       run: |
         ./LuaBridgeTestsLuaJIT.exe
+        ./LuaBridgeTestsLuaJITReflect.exe
         ./LuaBridgeTestsLuaJITNoexcept.exe
+        ./LuaBridgeTestsLuaJITReflectNoexcept.exe
 
   luau:
     runs-on: windows-latest
@@ -119,12 +123,16 @@ jobs:
     - name: Build Luau
       working-directory: ${{runner.workspace}}/build
       shell: bash
-      run: cmake --build . --config $BUILD_TYPE --parallel 4 --target LuaBridgeTestsLuau
+      run: cmake --build . --config $BUILD_TYPE --parallel 4 --target \
+        LuaBridgeTestsLuau \
+        LuaBridgeTestsLuauReflect
 
     - name: Test Luau
       working-directory: ${{runner.workspace}}/build/Tests/Release
       shell: bash
-      run: ./LuaBridgeTestsLuau.exe
+      run: |
+        ./LuaBridgeTestsLuau.exe
+        ./LuaBridgeTestsLuauReflect.exe
 
   ravi:
     runs-on: windows-latest
@@ -145,7 +153,9 @@ jobs:
     - name: Build Ravi
       working-directory: ${{runner.workspace}}/build
       shell: bash
-      run: cmake --build . --config $BUILD_TYPE --parallel 4 --target LuaBridgeTestsRavi
+      run: cmake --build . --config $BUILD_TYPE --parallel 4 --target \
+        LuaBridgeTestsRavi \
+        LuaBridgeTestsRaviReflect
 
     - name: Test Ravi
       working-directory: ${{runner.workspace}}/build/Tests/Release
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index 273a60fc..5de1d5dc 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -110,13 +110,17 @@ jobs:
       run: |
         cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
           LuaBridgeTestsLuaJIT \
-          LuaBridgeTestsLuaJITNoexcept
+          LuaBridgeTestsLuaJITReflect \
+          LuaBridgeTestsLuaJITNoexcept \
+          LuaBridgeTestsLuaJITReflectNoexcept
 
     - name: Test LuaJIT
       working-directory: ${{runner.workspace}}/build/Tests
       run: |
         ./LuaBridgeTestsLuaJIT
+        ./LuaBridgeTestsLuaJITReflect
         ./LuaBridgeTestsLuaJITNoexcept
+        ./LuaBridgeTestsLuaJITReflectNoexcept
 
     - name: Coverage LuaJIT
       working-directory: ${{runner.workspace}}/build
@@ -154,11 +158,15 @@ jobs:
 
     - name: Build Luau
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target LuaBridgeTestsLuau
+      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+        LuaBridgeTestsLuau \
+        LuaBridgeTestsLuauReflect
 
     - name: Test Luau
       working-directory: ${{runner.workspace}}/build/Tests
-      run: ./LuaBridgeTestsLuau
+      run: |
+        ./LuaBridgeTestsLuau
+        ./LuaBridgeTestsLuauReflect
 
     - name: Coverage Luau
       working-directory: ${{runner.workspace}}/build
@@ -196,11 +204,15 @@ jobs:
 
     - name: Build Ravi
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target LuaBridgeTestsRavi
+      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+        LuaBridgeTestsRavi \
+        LuaBridgeTestsRaviReflect
 
     - name: Test Ravi
       working-directory: ${{runner.workspace}}/build/Tests
-      run: LD_PRELOAD=$(gcc -print-file-name=libasan.so) ./LuaBridgeTestsRavi
+      run: |
+        ./LuaBridgeTestsRavi
+        ./LuaBridgeTestsRaviReflect
 
     - name: Coverage Ravi
       working-directory: ${{runner.workspace}}/build
@@ -303,7 +315,7 @@ jobs:
 
       #- name: Convert to Coverage TXT
       #  working-directory: ${{runner.workspace}}/build
-      #  run: python3 ${{runner.workspace}}/cobertura.py coverage/cobertura.info coverage/coverage.txt
+      #  run: python3 ${{runner.workspace}}/Tools/cobertura.py coverage/cobertura.info coverage/coverage.txt
 
       - name: Upload Cobertura XML
         uses: actions/upload-artifact@v4
diff --git a/amalgamate.py b/Tools/amalgamate.py
similarity index 100%
rename from amalgamate.py
rename to Tools/amalgamate.py
diff --git a/cobertura.py b/Tools/cobertura.py
similarity index 100%
rename from cobertura.py
rename to Tools/cobertura.py
diff --git a/justfile b/justfile
index ae502c91..67f15fae 100644
--- a/justfile
+++ b/justfile
@@ -26,5 +26,4 @@ clean:
     rm -rf Build/
 
 amalgamate:
-    uv run amalgamate.py
-
+    uv run Tools/amalgamate.py

From 7e9ddf096128e606d42bb6b9ffbbd84af840eea8 Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Tue, 7 Apr 2026 17:54:15 +0200
Subject: [PATCH 04/14] Fix github actions

---
 .github/workflows/build_linux.yml   | 14 ++++++++------
 .github/workflows/build_macos.yml   | 14 ++++++++------
 .github/workflows/build_windows.yml | 14 ++++++++------
 .github/workflows/coverage.yml      | 14 ++++++++------
 4 files changed, 32 insertions(+), 24 deletions(-)

diff --git a/.github/workflows/build_linux.yml b/.github/workflows/build_linux.yml
index ac051712..8e96d6dd 100644
--- a/.github/workflows/build_linux.yml
+++ b/.github/workflows/build_linux.yml
@@ -126,9 +126,10 @@ jobs:
 
     - name: Build Luau
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
-        LuaBridgeTestsLuau \
-        LuaBridgeTestsLuauReflect
+      run: |
+        cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+          LuaBridgeTestsLuau \
+          LuaBridgeTestsLuauReflect
 
     - name: Test Luau
       working-directory: ${{runner.workspace}}/build/Tests
@@ -156,9 +157,10 @@ jobs:
 
     - name: Build Ravi
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
-        LuaBridgeTestsRavi \
-        LuaBridgeTestsRaviReflect
+      run: |
+        cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+          LuaBridgeTestsRavi \
+          LuaBridgeTestsRaviReflect
 
     - name: Test Ravi
       working-directory: ${{runner.workspace}}/build/Tests
diff --git a/.github/workflows/build_macos.yml b/.github/workflows/build_macos.yml
index 50cd8ce7..aab1980b 100644
--- a/.github/workflows/build_macos.yml
+++ b/.github/workflows/build_macos.yml
@@ -115,9 +115,10 @@ jobs:
 
     - name: Build Luau
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
-        LuaBridgeTestsLuau \
-        LuaBridgeTestsLuauReflect
+      run: |
+        cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+          LuaBridgeTestsLuau \
+          LuaBridgeTestsLuauReflect
 
     - name: Test Luau
       working-directory: ${{runner.workspace}}/build/Tests
@@ -142,9 +143,10 @@ jobs:
 
     - name: Build Ravi
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
-        LuaBridgeTestsRavi \
-        LuaBridgeTestsRaviReflect
+      run: |
+        cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+          LuaBridgeTestsRavi \
+          LuaBridgeTestsRaviReflect
 
     - name: Test Ravi
       working-directory: ${{runner.workspace}}/build/Tests
diff --git a/.github/workflows/build_windows.yml b/.github/workflows/build_windows.yml
index 3670bc0a..55987944 100644
--- a/.github/workflows/build_windows.yml
+++ b/.github/workflows/build_windows.yml
@@ -123,9 +123,10 @@ jobs:
     - name: Build Luau
       working-directory: ${{runner.workspace}}/build
       shell: bash
-      run: cmake --build . --config $BUILD_TYPE --parallel 4 --target \
-        LuaBridgeTestsLuau \
-        LuaBridgeTestsLuauReflect
+      run: |
+        cmake --build . --config $BUILD_TYPE --parallel 4 --target \
+          LuaBridgeTestsLuau \
+          LuaBridgeTestsLuauReflect
 
     - name: Test Luau
       working-directory: ${{runner.workspace}}/build/Tests/Release
@@ -153,9 +154,10 @@ jobs:
     - name: Build Ravi
       working-directory: ${{runner.workspace}}/build
       shell: bash
-      run: cmake --build . --config $BUILD_TYPE --parallel 4 --target \
-        LuaBridgeTestsRavi \
-        LuaBridgeTestsRaviReflect
+      run: |
+        cmake --build . --config $BUILD_TYPE --parallel 4 --target \
+          LuaBridgeTestsRavi \
+          LuaBridgeTestsRaviReflect
 
     - name: Test Ravi
       working-directory: ${{runner.workspace}}/build/Tests/Release
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index 5de1d5dc..c47de62b 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -158,9 +158,10 @@ jobs:
 
     - name: Build Luau
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
-        LuaBridgeTestsLuau \
-        LuaBridgeTestsLuauReflect
+      run: |
+        cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+          LuaBridgeTestsLuau \
+          LuaBridgeTestsLuauReflect
 
     - name: Test Luau
       working-directory: ${{runner.workspace}}/build/Tests
@@ -204,9 +205,10 @@ jobs:
 
     - name: Build Ravi
       working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
-        LuaBridgeTestsRavi \
-        LuaBridgeTestsRaviReflect
+      run: |
+        cmake --build . --config $BUILD_TYPE --parallel $(nproc) --target \
+          LuaBridgeTestsRavi \
+          LuaBridgeTestsRaviReflect
 
     - name: Test Ravi
       working-directory: ${{runner.workspace}}/build/Tests

From c47b829116849b046fca155a80801a35d360f713 Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Tue, 7 Apr 2026 17:59:08 +0200
Subject: [PATCH 05/14] Fix warnings

---
 .github/workflows/coverage.yml | 4 ++--
 Tests/Lua/Luau.cpp             | 6 ++++++
 Tests/Lua/LuauSplit.cpp        | 6 ++++++
 3 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index c47de62b..44acd1a2 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -213,8 +213,8 @@ jobs:
     - name: Test Ravi
       working-directory: ${{runner.workspace}}/build/Tests
       run: |
-        ./LuaBridgeTestsRavi
-        ./LuaBridgeTestsRaviReflect
+        LD_PRELOAD=$(gcc -print-file-name=libasan.so) ./LuaBridgeTestsRavi
+        LD_PRELOAD=$(gcc -print-file-name=libasan.so) ./LuaBridgeTestsRaviReflect
 
     - name: Coverage Ravi
       working-directory: ${{runner.workspace}}/build
diff --git a/Tests/Lua/Luau.cpp b/Tests/Lua/Luau.cpp
index 297cde0e..bc5f5580 100644
--- a/Tests/Lua/Luau.cpp
+++ b/Tests/Lua/Luau.cpp
@@ -36,6 +36,10 @@
 #ifndef _CRT_SECURE_NO_WARNINGS
 #define _CRT_SECURE_NO_WARNINGS
 #endif
+#elif __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpragmas"
+#pragma GCC diagnostic ignored "-Wunused-variable"
 #endif
 
 // Ast
@@ -83,6 +87,8 @@
 
 #if _MSC_VER
 #pragma pop_macro("_CRT_SECURE_NO_WARNINGS")
+#elif __GNUC__
+#pragma GCC diagnostic pop
 #endif
 
 #else
diff --git a/Tests/Lua/LuauSplit.cpp b/Tests/Lua/LuauSplit.cpp
index 4fec0a70..6f7155a8 100644
--- a/Tests/Lua/LuauSplit.cpp
+++ b/Tests/Lua/LuauSplit.cpp
@@ -36,6 +36,10 @@
 #ifndef _CRT_SECURE_NO_WARNINGS
 #define _CRT_SECURE_NO_WARNINGS
 #endif
+#elif __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpragmas"
+#pragma GCC diagnostic ignored "-Wunused-variable"
 #endif
 
 // Compiler
@@ -63,6 +67,8 @@
 
 #if _MSC_VER
 #pragma pop_macro("_CRT_SECURE_NO_WARNINGS")
+#elif __GNUC__
+#pragma GCC diagnostic pop
 #endif
 
 #else

From 586f7bcc8c5e754bd0887d6bc0c417c6ad9bedcb Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Tue, 7 Apr 2026 19:38:56 +0200
Subject: [PATCH 06/14] More cleanups

---
 Source/LuaBridge/Inspect.h           | 309 +++++++++++++--------------
 Source/LuaBridge/detail/CFunctions.h |  32 +++
 Source/LuaBridge/detail/ClassInfo.h  |  11 +
 Source/LuaBridge/detail/FuncTraits.h |  30 +++
 Source/LuaBridge/detail/Namespace.h  |  18 ++
 Tests/Source/InspectTests.cpp        |  37 ++--
 6 files changed, 250 insertions(+), 187 deletions(-)

diff --git a/Source/LuaBridge/Inspect.h b/Source/LuaBridge/Inspect.h
index 1dc75ac1..4e0e7613 100644
--- a/Source/LuaBridge/Inspect.h
+++ b/Source/LuaBridge/Inspect.h
@@ -9,7 +9,9 @@
 #include "detail/LuaHelpers.h"
 
 #include <iostream>
+#include <map>
 #include <set>
+#include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
@@ -335,13 +337,33 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
     }
     lua_pop(L, 1);
 
+    // Collect instance property type names (may be absent if not registered with type info)
+    std::map<std::string, std::string> instPropTypes;
+    lua_rawgetp_x(L, clIdx, getPropTypeKey());
+    if (lua_istable(L, -1))
+    {
+        int ptIdx = lua_absindex(L, -1);
+        for (const auto& k : instPropget)
+        {
+            lua_getfield(L, ptIdx, k.c_str());
+            if (lua_isstring(L, -1))
+                instPropTypes[k] = lua_tostring(L, -1);
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1);
+
     // 4. Emit instance properties
     for (const auto& propName : instPropget)
     {
         MemberInfo m;
         m.name = propName;
         m.kind = instPropsetReal.count(propName) ? MemberKind::Property : MemberKind::ReadOnlyProperty;
-        m.overloads.push_back(OverloadInfo{});
+        OverloadInfo ov;
+        auto it = instPropTypes.find(propName);
+        if (it != instPropTypes.end())
+            ov.returnType = it->second;
+        m.overloads.push_back(std::move(ov));
         cls.members.push_back(std::move(m));
     }
 
@@ -398,13 +420,33 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
     }
     lua_pop(L, 1);
 
+    // Collect static property type names
+    std::map<std::string, std::string> stPropTypes;
+    lua_rawgetp_x(L, mtIdx, getPropTypeKey());
+    if (lua_istable(L, -1))
+    {
+        int ptIdx = lua_absindex(L, -1);
+        for (const auto& k : stPropget)
+        {
+            lua_getfield(L, ptIdx, k.c_str());
+            if (lua_isstring(L, -1))
+                stPropTypes[k] = lua_tostring(L, -1);
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1);
+
     // 7. Emit static properties
     for (const auto& propName : stPropget)
     {
         MemberInfo m;
         m.name = propName;
         m.kind = stPropsetReal.count(propName) ? MemberKind::StaticProperty : MemberKind::StaticReadOnlyProperty;
-        m.overloads.push_back(OverloadInfo{});
+        OverloadInfo ov;
+        auto it = stPropTypes.find(propName);
+        if (it != stPropTypes.end())
+            ov.returnType = it->second;
+        m.overloads.push_back(std::move(ov));
         cls.members.push_back(std::move(m));
     }
 
@@ -467,6 +509,22 @@ inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::
         nsPropsetTableIdx = lua_absindex(L, -1);
     // leave propset table on stack; we pop it after the loop
 
+    // Collect namespace property type names
+    std::map<std::string, std::string> nsPropTypes;
+    lua_rawgetp_x(L, nsIdx, getPropTypeKey());
+    if (lua_istable(L, -1))
+    {
+        int ptIdx = lua_absindex(L, -1);
+        for (const auto& k : nsPropget)
+        {
+            lua_getfield(L, ptIdx, k.c_str());
+            if (lua_isstring(L, -1))
+                nsPropTypes[k] = lua_tostring(L, -1);
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1); // pop proptype table or nil
+
     for (const auto& propName : nsPropget)
     {
         MemberInfo m;
@@ -487,7 +545,11 @@ inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::
         }
 
         m.kind = isReadOnly ? MemberKind::ReadOnlyProperty : MemberKind::Property;
-        m.overloads.push_back(OverloadInfo{});
+        OverloadInfo ov;
+        auto it = nsPropTypes.find(propName);
+        if (it != nsPropTypes.end())
+            ov.returnType = it->second;
+        m.overloads.push_back(std::move(ov));
         info.freeMembers.push_back(std::move(m));
     }
 
@@ -850,7 +912,7 @@ class LuaLSVisitor : public InspectVisitor
 
         for (const auto& ov : m.overloads)
         {
-            emitParams(ov.params);
+            emitParamsTo(out_, ov.params);
             if (!ov.returnType.empty() && ov.returnType != "void")
                 out_ << "---@return " << luaType(ov.returnType) << "\n";
         }
@@ -873,96 +935,101 @@ class LuaLSVisitor : public InspectVisitor
                 out_ << ", " << cls.baseClasses[i];
         }
         out_ << "\n";
-
-        // Emit fields for properties in the class body annotation
-        // (will be added in visitMember below, but need the class annotation open)
+        methodBuf_.str({});
+        methodBuf_.clear();
     }
 
     void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
-        out_ << "local " << curClass_ << " = {}\n\n";
+        out_ << "local " << curClass_ << " = {}\n";
+        const std::string methods = methodBuf_.str();
+        if (!methods.empty())
+            out_ << "\n" << methods;
+        else
+            out_ << "\n";
         curClass_.clear();
     }
 
     void visitMember(const ClassInspectInfo& cls, const MemberInfo& m) override
     {
+        auto propType = [&]() -> std::string {
+            if (!m.overloads.empty() && !m.overloads[0].returnType.empty())
+                return luaType(m.overloads[0].returnType);
+            return "any";
+        };
+
         switch (m.kind)
         {
         case MemberKind::Property:
-            out_ << "---@field " << m.name << " any\n";
+            out_ << "---@field " << m.name << " " << propType() << "\n";
             break;
+
         case MemberKind::ReadOnlyProperty:
-            out_ << "---@field " << m.name << " any # readonly\n";
+            out_ << "---@field " << m.name << " " << propType() << " # readonly\n";
             break;
+
         case MemberKind::StaticProperty:
-            out_ << "---@field " << m.name << " any\n";
+            out_ << "---@field " << m.name << " " << propType() << "\n";
             break;
+
         case MemberKind::StaticReadOnlyProperty:
-            out_ << "---@field " << m.name << " any # readonly\n";
+            out_ << "---@field " << m.name << " " << propType() << " # readonly\n";
             break;
+
         case MemberKind::Constructor:
         {
-            out_ << "\n";
-            for (std::size_t i = 0; i < m.overloads.size(); ++i)
-            {
-                const auto& ov = m.overloads[i];
-                if (i == 0)
-                {
-                    emitParams(ov.params);
-                    out_ << "---@return " << cls.name << "\n";
-                    out_ << "function " << cls.name << ".new(" << paramNames(ov.params) << ") end\n";
-                }
-                else
-                {
-                    out_ << "---@overload fun(" << overloadParams(ov.params) << "): " << cls.name << "\n";
-                }
-            }
+            // Represent the constructor as @overload annotations before the local declaration.
+            // LuaBridge constructors are called as ClassName(args), not ClassName.new(args).
+            std::string qname = qualifiedName(cls.name);
+            for (const auto& ov : m.overloads)
+                out_ << "---@overload fun(" << overloadParams(ov.params) << "): " << qname << "\n";
             break;
         }
+
         case MemberKind::Method:
         {
-            out_ << "\n";
+            std::string qname = qualifiedName(cls.name);
             for (std::size_t i = 0; i < m.overloads.size(); ++i)
             {
                 const auto& ov = m.overloads[i];
                 if (i == 0)
                 {
-                    emitParams(ov.params, /*hasSelf=*/true);
+                    emitParamsTo(methodBuf_, ov.params, /*hasSelf=*/true, qname);
                     if (!ov.returnType.empty() && ov.returnType != "void")
-                        out_ << "---@return " << luaType(ov.returnType) << "\n";
-                    out_ << "function " << cls.name << ":" << m.name
-                         << "(" << paramNames(ov.params) << ") end\n";
+                        methodBuf_ << "---@return " << luaType(ov.returnType) << "\n";
+                    methodBuf_ << "function " << qname << ":" << m.name << "(" << paramNames(ov.params) << ") end\n\n";
                 }
                 else
                 {
-                    out_ << "---@overload fun(self: " << cls.name << ", " << overloadParams(ov.params) << ")"
-                         << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
+                    methodBuf_ << "---@overload fun(self: " << qname << ", " << overloadParams(ov.params) << ")"
+                               << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
                 }
             }
             break;
         }
+
         case MemberKind::StaticMethod:
         {
-            out_ << "\n";
+            std::string qname = qualifiedName(cls.name);
             for (std::size_t i = 0; i < m.overloads.size(); ++i)
             {
                 const auto& ov = m.overloads[i];
                 if (i == 0)
                 {
-                    emitParams(ov.params);
+                    emitParamsTo(methodBuf_, ov.params);
                     if (!ov.returnType.empty() && ov.returnType != "void")
-                        out_ << "---@return " << luaType(ov.returnType) << "\n";
-                    out_ << "function " << cls.name << "." << m.name
-                         << "(" << paramNames(ov.params) << ") end\n";
+                        methodBuf_ << "---@return " << luaType(ov.returnType) << "\n";
+                    methodBuf_ << "function " << qname << "." << m.name << "(" << paramNames(ov.params) << ") end\n\n";
                 }
                 else
                 {
-                    out_ << "---@overload fun(" << overloadParams(ov.params) << ")"
-                         << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
+                    methodBuf_ << "---@overload fun(" << overloadParams(ov.params) << ")"
+                               << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
                 }
             }
             break;
         }
+
         default:
             break;
         }
@@ -973,15 +1040,20 @@ class LuaLSVisitor : public InspectVisitor
     static std::string luaType(const std::string& cppType)
     {
         if (cppType == "void") return "nil";
+
         if (cppType == "bool") return "boolean";
+
         if (cppType == "int" || cppType == "long" || cppType == "short" ||
             cppType == "unsigned int" || cppType == "unsigned long" ||
             cppType == "unsigned short" || cppType == "int64_t" || cppType == "uint64_t" ||
             cppType == "int32_t" || cppType == "uint32_t" || cppType == "size_t")
             return "integer";
+
         if (cppType == "float" || cppType == "double") return "number";
+
         if (cppType == "std::string" || cppType == "const char *" || cppType == "const char*")
             return "string";
+
         return cppType.empty() ? "any" : cppType;
     }
 
@@ -1007,6 +1079,7 @@ class LuaLSVisitor : public InspectVisitor
         for (std::size_t i = 0; i < params.size(); ++i)
         {
             if (i) s += ", ";
+
             const auto& p = params[i];
             std::string pname = p.hint.empty() ? ("p" + std::to_string(i + 1)) : p.hint;
             s += pname + ": " + luaType(p.typeName.empty() ? "any" : p.typeName);
@@ -1014,20 +1087,23 @@ class LuaLSVisitor : public InspectVisitor
         return s;
     }
 
-    void emitParams(const std::vector<ParamInfo>& params, bool hasSelf = false) const
+    static void emitParamsTo(std::ostream& os, const std::vector<ParamInfo>& params,
+                             bool hasSelf = false, const std::string& selfType = {})
     {
         if (hasSelf)
-            out_ << "---@param self " << curClass_ << "\n";
+            os << "---@param self " << selfType << "\n";
+
         for (std::size_t i = 0; i < params.size(); ++i)
         {
             const auto& p = params[i];
             std::string pname = p.hint.empty() ? ("p" + std::to_string(i + 1)) : p.hint;
             std::string ptype = p.typeName.empty() ? "any" : luaType(p.typeName);
-            out_ << "---@param " << pname << " " << ptype << "\n";
+            os << "---@param " << pname << " " << ptype << "\n";
         }
     }
 
     std::ostream& out_;
+    std::ostringstream methodBuf_;
     std::string ns_;
     std::string curClass_;
 };
@@ -1049,14 +1125,16 @@ class LuaProxyVisitor : public InspectVisitor
 
     void beginNamespace(const NamespaceInspectInfo& ns) override
     {
-        if (ns.name != "_G")
-            out_ << "local " << ns.name << " = {}\n\n";
+        curNs_ = (ns.name == "_G") ? "" : ns.name;
+        if (!curNs_.empty())
+            out_ << "local " << curNs_ << " = {}\n\n";
     }
 
     void endNamespace(const NamespaceInspectInfo& ns) override
     {
         if (ns.name != "_G")
             out_ << "return " << ns.name << "\n";
+        curNs_.clear();
     }
 
     void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) override
@@ -1074,8 +1152,9 @@ class LuaProxyVisitor : public InspectVisitor
     void beginClass(const ClassInspectInfo& cls) override
     {
         curClass_ = cls.name;
-        out_ << cls.name << " = {}\n";
-        out_ << cls.name << ".__index = " << cls.name << "\n\n";
+        std::string qname = curNs_.empty() ? cls.name : (curNs_ + "." + cls.name);
+        out_ << qname << " = {}\n";
+        out_ << qname << ".__index = " << qname << "\n\n";
     }
 
     void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
@@ -1089,28 +1168,35 @@ class LuaProxyVisitor : public InspectVisitor
         if (m.overloads.empty())
             return;
 
+        std::string qname = curNs_.empty() ? curClass_ : (curNs_ + "." + curClass_);
+
         switch (m.kind)
         {
         case MemberKind::Constructor:
-            out_ << "function " << curClass_ << ".new("
-                 << paramNames(m.overloads[0].params) << ")\n"
-                 << "    return setmetatable({}, " << curClass_ << ")\n"
-                 << "end\n\n";
+            // LuaBridge constructors are called as ClassName(args) via __call metamethod.
+            out_ << "setmetatable(" << qname << ", {__call = function(t";
+            if (!m.overloads[0].params.empty())
+                out_ << ", " << paramNames(m.overloads[0].params);
+            out_ << ")\n    return setmetatable({}, t)\nend})\n\n";
             break;
+
         case MemberKind::Method:
-            out_ << "function " << curClass_ << ":" << m.name
-                 << "(" << paramNames(m.overloads[0].params) << ") end\n";
+            out_ << "function " << qname << ":" << m.name
+                 << "(" << paramNames(m.overloads[0].params) << ") end\n\n";
             break;
+
         case MemberKind::StaticMethod:
-            out_ << "function " << curClass_ << "." << m.name
-                 << "(" << paramNames(m.overloads[0].params) << ") end\n";
+            out_ << "function " << qname << "." << m.name
+                 << "(" << paramNames(m.overloads[0].params) << ") end\n\n";
             break;
+
         case MemberKind::Property:
         case MemberKind::ReadOnlyProperty:
         case MemberKind::StaticProperty:
         case MemberKind::StaticReadOnlyProperty:
             // Properties are part of the table, no explicit function needed
             break;
+
         default:
             break;
         }
@@ -1129,119 +1215,10 @@ class LuaProxyVisitor : public InspectVisitor
     }
 
     std::ostream& out_;
+    std::string curNs_;
     std::string curClass_;
 };
 
-//=================================================================================================
-/**
- * @brief Visitor that emits a JSON representation of the inspection tree.
- */
-class JsonVisitor : public InspectVisitor
-{
-public:
-    explicit JsonVisitor(std::ostream& out)
-        : out_(out)
-    {
-    }
-
-    void beginNamespace(const NamespaceInspectInfo& ns) override
-    {
-        if (depth_ == 0) out_ << "{\n";
-        indent(); out_ << "\"name\": \"" << escape(ns.name) << "\",\n";
-        indent(); out_ << "\"freeMembers\": [],\n";
-        indent(); out_ << "\"classes\": [\n";
-        ++depth_;
-        firstClass_ = true;
-    }
-
-    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
-    {
-        --depth_;
-        out_ << "\n";
-        indent(); out_ << "]\n";
-        if (depth_ == 0) out_ << "}\n";
-    }
-
-    void beginClass(const ClassInspectInfo& cls) override
-    {
-        if (!firstClass_) out_ << ",\n";
-        firstClass_ = false;
-        indent(); out_ << "{\n";
-        ++depth_;
-        indent(); out_ << "\"name\": \"" << escape(cls.name) << "\",\n";
-        indent(); out_ << "\"bases\": [";
-        for (std::size_t i = 0; i < cls.baseClasses.size(); ++i)
-        {
-            if (i) out_ << ", ";
-            out_ << "\"" << escape(cls.baseClasses[i]) << "\"";
-        }
-        out_ << "],\n";
-        indent(); out_ << "\"members\": [\n";
-        ++depth_;
-        firstMember_ = true;
-    }
-
-    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
-    {
-        --depth_;
-        out_ << "\n";
-        indent(); out_ << "]\n";
-        --depth_;
-        indent(); out_ << "}";
-    }
-
-    void visitMember([[maybe_unused]] const ClassInspectInfo& cls, const MemberInfo& m) override
-    {
-        if (!firstMember_) out_ << ",\n";
-        firstMember_ = false;
-        indent();
-        out_ << "{ \"name\": \"" << escape(m.name) << "\""
-             << ", \"kind\": \"" << kindStr(m.kind) << "\""
-             << ", \"overloads\": " << m.overloads.size()
-             << " }";
-    }
-
-private:
-    void indent() const
-    {
-        for (int i = 0; i < depth_; ++i)
-            out_ << "  ";
-    }
-
-    static std::string escape(const std::string& s)
-    {
-        std::string out;
-        for (char c : s)
-        {
-            if (c == '"') out += "\\\"";
-            else if (c == '\\') out += "\\\\";
-            else out += c;
-        }
-        return out;
-    }
-
-    static const char* kindStr(MemberKind k)
-    {
-        switch (k)
-        {
-        case MemberKind::Method: return "method";
-        case MemberKind::StaticMethod: return "static_method";
-        case MemberKind::Property: return "property";
-        case MemberKind::ReadOnlyProperty: return "readonly_property";
-        case MemberKind::StaticProperty: return "static_property";
-        case MemberKind::StaticReadOnlyProperty: return "static_readonly_property";
-        case MemberKind::Constructor: return "constructor";
-        case MemberKind::Metamethod: return "metamethod";
-        default: return "unknown";
-        }
-    }
-
-    std::ostream& out_;
-    int depth_ = 0;
-    bool firstClass_ = true;
-    bool firstMember_ = true;
-};
-
 //=================================================================================================
 /**
  * @brief Visitor that builds a structured Lua table on the Lua stack.
diff --git a/Source/LuaBridge/detail/CFunctions.h b/Source/LuaBridge/detail/CFunctions.h
index dfbb2610..0bd474f8 100644
--- a/Source/LuaBridge/detail/CFunctions.h
+++ b/Source/LuaBridge/detail/CFunctions.h
@@ -1391,6 +1391,38 @@ inline void add_property_getter(lua_State* L, const char* name, int tableIndex)
     lua_pop(L, 2); // Stack: -
 }
 
+//=================================================================================================
+/**
+ * @brief Store a property's C++ type name string in a side-table for inspection/tooling.
+ *
+ * Creates the side-table (keyed by getPropTypeKey()) on demand inside the table at tableIndex.
+ * A no-op when typeName is null or empty.
+ */
+inline void add_property_type(lua_State* L, const char* name, const char* typeName, int tableIndex)
+{
+#if LUABRIDGE_SAFE_STACK_CHECKS
+    luaL_checkstack(L, 3, detail::error_lua_stack_overflow);
+#endif
+
+    if (!typeName || typeName[0] == '\0')
+        return;
+
+    tableIndex = lua_absindex(L, tableIndex);
+
+    lua_rawgetp_x(L, tableIndex, getPropTypeKey()); // Stack: ..., proptype (or nil)
+    if (lua_isnil(L, -1))
+    {
+        lua_pop(L, 1);
+        lua_createtable(L, 0, 4);
+        lua_pushvalue(L, -1);
+        lua_rawsetp_x(L, tableIndex, getPropTypeKey());
+    }
+    // Stack: ..., proptype
+    lua_pushstring(L, typeName);
+    rawsetfield(L, -2, name);
+    lua_pop(L, 1); // pop proptype
+}
+
 //=================================================================================================
 
 template <class T, class C = void>
diff --git a/Source/LuaBridge/detail/ClassInfo.h b/Source/LuaBridge/detail/ClassInfo.h
index ad90f244..603037d5 100644
--- a/Source/LuaBridge/detail/ClassInfo.h
+++ b/Source/LuaBridge/detail/ClassInfo.h
@@ -146,6 +146,17 @@ template <class T, auto = typeName<T>().find_first_of('.')>
     return reinterpret_cast<void*>(0xdad);
 }
 
+//=================================================================================================
+/**
+ * @brief The key of a property-type table in a class/namespace metatable.
+ *
+ * Maps property names to their C++ return type strings (for inspection/IDE tooling).
+ */
+[[nodiscard]] inline const void* getPropTypeKey() noexcept
+{
+    return reinterpret_cast<void*>(0x9e7);
+}
+
 //=================================================================================================
 /**
  * @brief The key of a cast offset table in a derived class metatable.
diff --git a/Source/LuaBridge/detail/FuncTraits.h b/Source/LuaBridge/detail/FuncTraits.h
index c121bc48..c87af0d4 100644
--- a/Source/LuaBridge/detail/FuncTraits.h
+++ b/Source/LuaBridge/detail/FuncTraits.h
@@ -547,5 +547,35 @@ struct remove_first_type<std::tuple<T, Ts...>>
 template <class T>
 using remove_first_type_t = typename remove_first_type<T>::type;
 
+//=================================================================================================
+/**
+ * @brief Deduces the value type of a property getter.
+ *
+ * Handles member object pointers (T C::*), callable getters (member functions, free
+ * functions, lambdas), and falls back to void for anything else.
+ */
+template <class Getter, class = void>
+struct getter_return_type
+{
+    using type = void;
+};
+
+// Member object pointer: T C::*  (not a function member pointer)
+template <class T, class C>
+struct getter_return_type<T C::*, std::enable_if_t<std::is_member_object_pointer_v<T C::*>>>
+{
+    using type = std::remove_const_t<T>;
+};
+
+// Callable getter (member function pointer, free function pointer, lambda/functor)
+template <class Getter>
+struct getter_return_type<Getter, std::enable_if_t<is_callable_v<Getter>>>
+{
+    using type = remove_cvref_t<function_result_t<Getter>>;
+};
+
+template <class Getter>
+using getter_return_t = typename getter_return_type<Getter>::type;
+
 } // namespace detail
 } // namespace luabridge
diff --git a/Source/LuaBridge/detail/Namespace.h b/Source/LuaBridge/detail/Namespace.h
index 0039f3e4..cdc0f60a 100644
--- a/Source/LuaBridge/detail/Namespace.h
+++ b/Source/LuaBridge/detail/Namespace.h
@@ -709,6 +709,9 @@ class Namespace : public detail::Registrar
             detail::push_property_readonly(L, name); // Stack: co, cl, st, function
             detail::add_property_setter(L, name, -2); // Stack: co, cl, st
 
+            using RetType = detail::getter_return_t<Getter>;
+            detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -1); // st
+
             return *this;
         }
 
@@ -724,6 +727,9 @@ class Namespace : public detail::Registrar
             detail::push_property_setter(L, std::move(set), name); // Stack: co, cl, st, function
             detail::add_property_setter(L, name, -2); // Stack: co, cl, st
 
+            using RetType = detail::getter_return_t<Getter>;
+            detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -1); // st
+
             return *this;
         }
 
@@ -926,6 +932,9 @@ class Namespace : public detail::Registrar
             detail::push_property_readonly(L, name); // Stack: co, cl, st, function
             detail::add_property_setter(L, name, -3); // Stack: co, cl, st
 
+            using RetType = detail::getter_return_t<Getter>;
+            detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -2); // cl
+
             return *this;
         }
 
@@ -943,6 +952,9 @@ class Namespace : public detail::Registrar
             detail::push_class_property_setter<T>(L, std::move(setter), name); // Stack: co, cl, st, setter
             detail::add_property_setter(L, name, -3); // Stack: co, cl, st
 
+            using RetType = detail::getter_return_t<Getter>;
+            detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -2); // cl
+
             return *this;
         }
 
@@ -2034,6 +2046,9 @@ class Namespace : public detail::Registrar
         detail::push_property_readonly(L, name); // Stack: ns, function
         detail::add_property_setter(L, name, -2); // Stack: ns
 
+        using RetType = detail::getter_return_t<Getter>;
+        detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -1); // ns
+
         return *this;
     }
 
@@ -2065,6 +2080,9 @@ class Namespace : public detail::Registrar
         detail::push_property_setter(L, std::move(setter), name); // Stack: ns, setter
         detail::add_property_setter(L, name, -2); // Stack: ns
 
+        using RetType = detail::getter_return_t<Getter>;
+        detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -1); // ns
+
         return *this;
     }
 
diff --git a/Tests/Source/InspectTests.cpp b/Tests/Source/InspectTests.cpp
index 54f22674..37d0eae2 100644
--- a/Tests/Source/InspectTests.cpp
+++ b/Tests/Source/InspectTests.cpp
@@ -347,7 +347,10 @@ TEST_F(InspectTests, LuaLSVisitorProducesAnnotations)
     luabridge::getGlobalNamespace(L)
         .beginNamespace("LuaLS")
             .beginClass<Cls>("Cls")
+                .addConstructor<void()>()
                 .addProperty("value", &Cls::getValue)
+                .addFunction("xyz", [](const Cls& self, int a) { return a + 1; })
+                .addStaticFunction("abc", [](bool, float, int) { return "42"; })
             .endClass()
         .endNamespace();
 
@@ -358,8 +361,19 @@ TEST_F(InspectTests, LuaLSVisitorProducesAnnotations)
 
     const auto result = ss.str();
     EXPECT_FALSE(result.empty());
-    EXPECT_NE(std::string::npos, result.find("@class"));
-    EXPECT_NE(std::string::npos, result.find("Cls"));
+    EXPECT_NE(std::string::npos, result.find("---@class LuaLS.Cls"));
+    EXPECT_NE(std::string::npos, result.find("---@field value integer # readonly"));
+    EXPECT_NE(std::string::npos, result.find("---@overload fun(): LuaLS.Cls"));
+    EXPECT_NE(std::string::npos, result.find("local Cls = {}"));
+    EXPECT_NE(std::string::npos, result.find("---@param self LuaLS.Cls"));
+    EXPECT_NE(std::string::npos, result.find("---@param p1 integer"));
+    EXPECT_NE(std::string::npos, result.find("---@return integer"));
+    EXPECT_NE(std::string::npos, result.find("function LuaLS.Cls:xyz(p1) end"));
+    EXPECT_NE(std::string::npos, result.find("---@param p1 boolean"));
+    EXPECT_NE(std::string::npos, result.find("---@param p2 number"));
+    EXPECT_NE(std::string::npos, result.find("---@param p3 integer"));
+    EXPECT_NE(std::string::npos, result.find("---@return string"));
+    EXPECT_NE(std::string::npos, result.find("function LuaLS.Cls.abc(p1, p2, p3) end"));
 }
 
 TEST_F(InspectTests, LuaProxyVisitorProducesStubs)
@@ -384,25 +398,6 @@ TEST_F(InspectTests, LuaProxyVisitorProducesStubs)
     EXPECT_NE(std::string::npos, result.find("method"));
 }
 
-TEST_F(InspectTests, JsonVisitorProducesJson)
-{
-    struct Cls {};
-    luabridge::getGlobalNamespace(L)
-        .beginNamespace("Json")
-            .beginClass<Cls>("Cls").endClass()
-        .endNamespace();
-
-    auto ns = luabridge::inspectNamespace(L, "Json");
-    std::stringstream ss;
-    luabridge::JsonVisitor v(ss);
-    luabridge::accept(ns, v);
-
-    const auto result = ss.str();
-    EXPECT_FALSE(result.empty());
-    EXPECT_NE(std::string::npos, result.find("\"name\""));
-    EXPECT_NE(std::string::npos, result.find("Json"));
-}
-
 //=================================================================================================
 // inspect<T>() stack balance test
 

From ac7916866407f8eb65f09d383d5d94860e781de1 Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Wed, 8 Apr 2026 00:20:22 +0200
Subject: [PATCH 07/14] Disable inspection when no REFLECT is defined

---
 Source/LuaBridge/Inspect.h    | 29 ++++++++++++++++++++++++-----
 Tests/Source/InspectTests.cpp |  7 +++++--
 2 files changed, 29 insertions(+), 7 deletions(-)

diff --git a/Source/LuaBridge/Inspect.h b/Source/LuaBridge/Inspect.h
index 4e0e7613..29b4d5b5 100644
--- a/Source/LuaBridge/Inspect.h
+++ b/Source/LuaBridge/Inspect.h
@@ -4,6 +4,10 @@
 
 #pragma once
 
+#if ! LUABRIDGE_ENABLE_REFLECT
+#error "This header is only for use when LUABRIDGE_ENABLE_REFLECT is active."
+#endif
+
 #include "detail/CFunctions.h"
 #include "detail/ClassInfo.h"
 #include "detail/LuaHelpers.h"
@@ -844,16 +848,29 @@ class ConsoleVisitor : public InspectVisitor
         switch (m.kind)
         {
         case MemberKind::Property:
-            indent(); out_ << m.name << ": any;\n"; break;
+            indent();
+            out_ << m.name << ": any;\n";
+            break;
+
         case MemberKind::ReadOnlyProperty:
-            indent(); out_ << "readonly " << m.name << ": any;\n"; break;
+            indent();
+            out_ << "readonly " << m.name << ": any;\n";
+            break;
+
         case MemberKind::StaticProperty:
-            indent(); out_ << "static " << m.name << ": any;\n"; break;
+            indent();
+            out_ << "static " << m.name << ": any;\n";
+            break;
+        
         case MemberKind::StaticReadOnlyProperty:
-            indent(); out_ << "static readonly " << m.name << ": any;\n"; break;
+            indent();
+            out_ << "static readonly " << m.name << ": any;\n";
+            break;
+
         case MemberKind::Metamethod:
             // Skip metamethods in TypeScript-style output
             break;
+
         case MemberKind::Constructor:
             for (const auto& ov : m.overloads)
             {
@@ -861,10 +878,11 @@ class ConsoleVisitor : public InspectVisitor
                 out_ << "constructor(" << paramStr(ov) << ");\n";
             }
             break;
+
         case MemberKind::Method:
         case MemberKind::StaticMethod:
         {
-            bool isStatic = (m.kind == MemberKind::StaticMethod);
+            const bool isStatic = (m.kind == MemberKind::StaticMethod);
             for (std::size_t i = 0; i < m.overloads.size(); ++i)
             {
                 indent();
@@ -873,6 +891,7 @@ class ConsoleVisitor : public InspectVisitor
             }
             break;
         }
+
         default:
             break;
         }
diff --git a/Tests/Source/InspectTests.cpp b/Tests/Source/InspectTests.cpp
index 37d0eae2..268f0a9f 100644
--- a/Tests/Source/InspectTests.cpp
+++ b/Tests/Source/InspectTests.cpp
@@ -1,10 +1,12 @@
 // https://github.com/kunitoki/LuaBridge3
-// Copyright 2024, kunitoki
+// Copyright 2026, kunitoki
 // SPDX-License-Identifier: MIT
 
 #include "TestBase.h"
 
 #include "LuaBridge/LuaBridge.h"
+
+#if LUABRIDGE_ENABLE_REFLECT
 #include "LuaBridge/Inspect.h"
 
 #include <algorithm>
@@ -360,6 +362,7 @@ TEST_F(InspectTests, LuaLSVisitorProducesAnnotations)
     luabridge::accept(ns, v);
 
     const auto result = ss.str();
+    std::cout << result << std::endl;
     EXPECT_FALSE(result.empty());
     EXPECT_NE(std::string::npos, result.find("---@class LuaLS.Cls"));
     EXPECT_NE(std::string::npos, result.find("---@field value integer # readonly"));
@@ -492,7 +495,6 @@ TEST_F(InspectTests, WithHintsOverloadsCompile)
     EXPECT_EQ(2u, m->overloads.size());
 }
 
-#if LUABRIDGE_ENABLE_REFLECT
 TEST_F(InspectTests, ReflectTypeInfoPopulated)
 {
     struct Enemy { void takeDamage(float /*amount*/, int /*count*/) {} };
@@ -552,4 +554,5 @@ TEST_F(InspectTests, ReflectFreeFunction)
     EXPECT_EQ("a", fn->overloads[0].params[0].hint);
     EXPECT_EQ("b", fn->overloads[0].params[1].hint);
 }
+
 #endif // LUABRIDGE_ENABLE_REFLECT

From 0da524f1755ffb72f1c108365152068be65ccd80 Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Wed, 8 Apr 2026 00:29:35 +0200
Subject: [PATCH 08/14] More docs

---
 Manual.md | 299 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 299 insertions(+)

diff --git a/Manual.md b/Manual.md
index e9f74774..51a710a6 100644
--- a/Manual.md
+++ b/Manual.md
@@ -33,6 +33,7 @@ Contents
     *   [2.4 - Property Member Proxies](#24---property-member-proxies)
     *   [2.5 - Function Member Proxies](#25---function-member-proxies)
     *   [2.5.1 - Function Overloading](#251---function-overloading)
+    *   [2.5.2 - Parameter Name Hints](#252---parameter-name-hints)
     *   [2.6 - Constructors](#26---constructors)
     *   [2.6.1 - Constructor Proxies](#261---constructor-proxies)
     *   [2.6.2 - Constructor Factories](#262---constructor-factories)
@@ -51,6 +52,13 @@ Contents
         *   [2.9.4 - LuaCoroutine - Awaiting a Lua Thread from C++](#294---luacoroutine----awaiting-a-lua-thread-from-c)
         *   [2.9.5 - Limitations](#295---limitations)
 
+*   [2.10 - Inspecting Registrations](#210---inspecting-registrations)
+
+    *   [2.10.1 - inspect\<T\> and inspectNamespace](#2101---inspectT-and-inspectnamespace)
+    *   [2.10.2 - Visitor API](#2102---visitor-api)
+    *   [2.10.3 - ConsoleVisitor](#2103---consolevisitor)
+    *   [2.10.4 - Enabling Full Type Information (LUABRIDGE_ENABLE_REFLECT)](#2104---enabling-full-type-information-luabridge_enable_reflect)
+
 *   [3 - Passing Objects](#3---passing-objects)
 
     *   [3.1 - C++ Lifetime](#31---c-lifetime)
@@ -84,6 +92,7 @@ Contents
     * [6.3 - LUABRIDGE_SAFE_LUA_C_EXCEPTION_HANDLING](#63---luabridge-safe-c-exception-handling)
     * [6.4 - LUABRIDGE_RAISE_UNREGISTERED_CLASS_USAGE](#64---luabridge-raise-unregistered-class-usage)
     * [6.5 - LUABRIDGE_HAS_CXX20_COROUTINES / LUABRIDGE_DISABLE_CXX20_COROUTINES](#65---luabridge-has-cxx20-coroutines--luabridge-disable-cxx20-coroutines)
+    * [6.6 - LUABRIDGE_ENABLE_REFLECT](#66---luabridge-enable-reflect)
 
 *   [Appendix - API Reference](#appendix---api-reference)
 
@@ -659,6 +668,40 @@ It's possible to mix lambdas, function pointers and member functions in overload
 
 Special attention needs to be given to the order (priority) of the overloads, based on the number and type of the arguments. Better to place first the overloads that can be called more frequently, and putting "stronger" types first: for example when having an overload taking an `int` and an overload taking `float`, as lua is not able to distinguish between them properly (until lua 5.4) the first overload will always be called.
 
+### 2.5.2 - Parameter Name Hints
+
+When `LUABRIDGE_ENABLE_REFLECT` is defined (see [6.6](#66---luabridge-enable-reflect)), LuaBridge captures the C++ type names of function parameters at compile time. You can additionally attach human-readable **parameter name hints** to any function using `luabridge::withHints`. These names are stored alongside the function and become available through the [Inspection API](#210---inspecting-registrations).
+
+```cpp
+#define LUABRIDGE_ENABLE_REFLECT
+#include <LuaBridge/LuaBridge.h>
+#include <LuaBridge/Inspect.h>
+
+struct Enemy
+{
+    void attack(Enemy* target, float damage);
+    void move(float x, float y, float z);
+};
+
+luabridge::getGlobalNamespace(L)
+    .beginNamespace("game")
+        .beginClass<Enemy>("Enemy")
+            .addFunction("attack", luabridge::withHints(&Enemy::attack, "target", "damage"))
+            .addFunction("move",   luabridge::withHints(&Enemy::move,   "x", "y", "z"))
+        .endClass()
+    .endNamespace();
+```
+
+`withHints` is transparent: it forwards all function-trait queries to the wrapped function, so it can be used anywhere a plain function pointer is accepted — including overloaded registrations:
+
+```cpp
+.addFunction("rotate",
+    luabridge::withHints(luabridge::overload<float>(&Vec::rotate),        "degrees"),
+    luabridge::withHints(luabridge::overload<const Quat&>(&Vec::rotate),  "quaternion"))
+```
+
+When `LUABRIDGE_ENABLE_REFLECT` is **not** defined, `withHints` is still accepted by the compiler and correctly strips the wrapper — the hints are simply ignored at runtime so there is no overhead.
+
 2.6 - Constructors
 ------------------
 
@@ -1427,6 +1470,134 @@ print(f())         -- -1 (done)
 * **Multi-value yield:** `co_yield` sends exactly one value per suspension. Use `std::tuple` or a struct if multiple values are needed.
 * **Thread safety:** Coroutine frames must be driven from a single OS thread.
 
+2.10 - Inspecting Registrations
+================================
+
+LuaBridge3 can introspect its own registration tables at runtime, making it straightforward to generate documentation, build IDE auto-complete databases, produce TypeScript type declarations, or validate that a binding matches an expected schema.
+
+The inspection API lives in the **optional** header `<LuaBridge/Inspect.h>`, which must be included separately and **requires** `LUABRIDGE_ENABLE_REFLECT` to be defined (see [6.6](#66---luabridge-enable-reflect)).
+
+```cpp
+#define LUABRIDGE_ENABLE_REFLECT
+#include <LuaBridge/LuaBridge.h>
+#include <LuaBridge/Inspect.h>
+```
+
+### 2.10.1 - inspect\<T\> and inspectNamespace
+
+Two top-level free functions collect inspection data without traversing any Lua tables from user code:
+
+**`inspect<T>(L)`** — returns a `ClassInspectInfo` for the single registered class `T`. Returns an empty struct if `T` has not been registered.
+
+```cpp
+auto info = luabridge::inspect<Enemy>(L);
+std::cout << info.name << "\n"; // "Enemy"
+for (const auto& m : info.members)
+    std::cout << "  " << m.name << "\n";
+```
+
+**`inspectNamespace(L, name)`** — returns a `NamespaceInspectInfo` for the given namespace. Pass `nullptr` or an empty string to inspect the global namespace `_G`. Dotted paths are supported.
+
+```cpp
+auto ns  = luabridge::inspectNamespace(L, "game");       // top-level namespace
+auto sub = luabridge::inspectNamespace(L, "game.util");  // nested namespace
+auto g   = luabridge::inspectNamespace(L);               // global namespace (_G)
+```
+
+The returned structures are plain data — they are independent copies that do not hold references to the Lua state:
+
+| Type | Fields |
+|------|--------|
+| `NamespaceInspectInfo` | `name`, `freeMembers`, `classes`, `subNamespaces` |
+| `ClassInspectInfo` | `name`, `baseClasses`, `members` |
+| `MemberInfo` | `name`, `kind` (`MemberKind`), `overloads` |
+| `OverloadInfo` | `returnType`, `params` (`vector<ParamInfo>`), `isConst` |
+| `ParamInfo` | `typeName`, `hint` |
+
+`MemberKind` is an enum with the following values:
+
+```cpp
+enum class MemberKind
+{
+    Method,
+    StaticMethod,
+    Property,
+    ReadOnlyProperty,
+    StaticProperty,
+    StaticReadOnlyProperty,
+    Constructor,
+    Metamethod,
+};
+```
+
+`returnType` and `typeName` are populated only when `LUABRIDGE_ENABLE_REFLECT` is defined. `hint` is populated when the function was registered with `luabridge::withHints` (see [2.5.2](#252---parameter-name-hints)).
+
+### 2.10.2 - Visitor API
+
+For namespace-wide traversal, a visitor-pattern API is provided. Derive from `InspectVisitor` and override only the callbacks you need:
+
+```cpp
+class InspectVisitor
+{
+public:
+    virtual void beginNamespace(const NamespaceInspectInfo& ns) {}
+    virtual void endNamespace  (const NamespaceInspectInfo& ns) {}
+    virtual void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) {}
+
+    virtual void beginClass(const ClassInspectInfo& cls) {}
+    virtual void endClass  (const ClassInspectInfo& cls) {}
+    virtual void visitMember(const ClassInspectInfo& cls, const MemberInfo& m) {}
+};
+```
+
+Drive a visitor over a pre-collected `NamespaceInspectInfo` using `accept`, or use the convenience wrapper `inspectAccept` that collects and visits in one call:
+
+```cpp
+// Option A: collect once, visit multiple times
+auto ns = luabridge::inspectNamespace(L, "game");
+MyVisitor v;
+luabridge::accept(ns, v);
+
+// Option B: collect and visit in a single call
+luabridge::inspectAccept(L, "game", v);
+```
+
+The traversal order for `accept` is:
+1. `beginNamespace`
+2. `visitFreeMember` for each free function / namespace-level property
+3. Recursive traversal of each class (begin → members → end)
+4. Recursive traversal of each sub-namespace
+5. `endNamespace`
+
+### 2.10.3 - ConsoleVisitor
+
+LuaBridge provides a ready-made visitor, `ConsoleVisitor`, that prints a TypeScript-style declaration to any `std::ostream` (defaults to `std::cerr`):
+
+```cpp
+luabridge::ConsoleVisitor printer(std::cout);
+luabridge::inspectAccept(L, "game", printer);
+```
+
+Example output for a `game` namespace containing an `Enemy` class:
+
+```
+namespace game {
+    class Enemy {
+        constructor(p1: any);
+        attack(target: Enemy, damage: float): void;
+        move(x: float, y: float, z: float): void;
+        readonly hp: int;
+        static create(p1: float, p2: float): Enemy;
+    }
+}
+```
+
+Type names and parameter names are filled in when `LUABRIDGE_ENABLE_REFLECT` is active and `withHints` was used during registration. Without reflection the output uses `any` for unknown types and `p1`, `p2`, … as placeholder parameter names.
+
+### 2.10.4 - Enabling Full Type Information (LUABRIDGE_ENABLE_REFLECT)
+
+See [6.6 - LUABRIDGE_ENABLE_REFLECT](#66---luabridge-enable-reflect) for the compile-time flag that activates C++ type-name capture. When the flag is off, the inspection API still works — it just reports empty strings for type names. The `withHints` parameter name hints work regardless of the flag.
+
 3 - Passing Objects
 ===================
 
@@ -2171,6 +2342,28 @@ You can also override the detection result explicitly:
 
 Attempting to use coroutine integration on Lua 5.1, LuaJIT, or Luau will emit a compile-time `#error` unless `LUABRIDGE_DISABLE_COROUTINE_INTEGRATION` is also defined.
 
+6.6 - LUABRIDGE_ENABLE_REFLECT
+-------------------------------
+
+**Default: not defined (disabled)**
+
+When defined, LuaBridge captures the C++ type names of function parameters and return types at compile time using `typeid`. This information is stored alongside the function in the Lua registry and is retrieved by the [Inspection API](#210---inspecting-registrations) to populate `OverloadInfo::returnType` and `ParamInfo::typeName`.
+
+Enable reflection by defining the macro **before** including any LuaBridge header:
+
+```cpp
+#define LUABRIDGE_ENABLE_REFLECT
+#include <LuaBridge/LuaBridge.h>
+#include <LuaBridge/Inspect.h>  // optional: only needed when using the inspection API
+```
+
+> **Note:** `Inspect.h` unconditionally requires `LUABRIDGE_ENABLE_REFLECT` and will emit a `#error` if the macro is not defined. You may use `withHints` (see [2.5.2](#252---parameter-name-hints)) without including `Inspect.h`.
+
+When `LUABRIDGE_ENABLE_REFLECT` is not defined:
+* `withHints` parameter name hints are still stored and available through inspection.
+* `OverloadInfo::returnType` and `ParamInfo::typeName` are empty strings.
+* The `Inspect.h` header cannot be included.
+
 Appendix - API Reference
 ========================
 
@@ -2610,3 +2803,109 @@ int lua_resume_x(lua_State* L, lua_State* from, int nargs, int* nresults = nullp
 /// Returns true if the current C function can yield via lua_yieldk.
 bool lua_isyieldable_x(lua_State* L);
 ```
+
+Registration Inspection (requires `LUABRIDGE_ENABLE_REFLECT`, `<LuaBridge/Inspect.h>`)
+---------------------------------------------------------------------------------------
+
+```cpp
+/// Kind of a registered member.
+enum class MemberKind
+{
+    Method,
+    StaticMethod,
+    Property,
+    ReadOnlyProperty,
+    StaticProperty,
+    StaticReadOnlyProperty,
+    Constructor,
+    Metamethod,
+};
+
+/// Type and optional name hint for one Lua-visible parameter of an overload.
+struct ParamInfo
+{
+    std::string typeName; ///< C++ type name (e.g. "float", "int", "MyClass"). Empty if unavailable.
+    std::string hint;     ///< Optional user-provided name (e.g. "damage"). Empty if not provided.
+};
+
+/// Type information for one overload of a registered function or constructor.
+struct OverloadInfo
+{
+    std::string returnType;        ///< C++ return type name. Empty if unavailable.
+    std::vector<ParamInfo> params; ///< One entry per Lua-visible parameter.
+    bool isConst = false;          ///< True when this is a const member function.
+};
+
+/// Information about one registered member (method, property, constructor, …).
+struct MemberInfo
+{
+    std::string name;
+    MemberKind kind = MemberKind::Method;
+    std::vector<OverloadInfo> overloads; ///< At least 1 entry; may contain empty OverloadInfo.
+};
+
+/// Inspection result for one registered class.
+struct ClassInspectInfo
+{
+    std::string name;
+    std::vector<std::string> baseClasses; ///< Names of all registered ancestor classes.
+    std::vector<MemberInfo> members;
+
+    void accept(InspectVisitor& v) const;
+};
+
+/// Inspection result for a namespace (may contain classes and sub-namespaces).
+struct NamespaceInspectInfo
+{
+    std::string name;
+    std::vector<MemberInfo> freeMembers;        ///< Free functions and namespace-level properties.
+    std::vector<ClassInspectInfo> classes;
+    std::vector<NamespaceInspectInfo> subNamespaces;
+
+    void accept(InspectVisitor& v) const;
+};
+
+/// Visitor interface for traversing an inspection result tree.
+class InspectVisitor
+{
+public:
+    virtual void beginNamespace(const NamespaceInspectInfo& ns) {}
+    virtual void endNamespace  (const NamespaceInspectInfo& ns) {}
+    virtual void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) {}
+
+    virtual void beginClass(const ClassInspectInfo& cls) {}
+    virtual void endClass  (const ClassInspectInfo& cls) {}
+    virtual void visitMember(const ClassInspectInfo& cls, const MemberInfo& m) {}
+};
+
+/// Built-in visitor that emits TypeScript-style pseudo-declarations to an ostream.
+class ConsoleVisitor : public InspectVisitor
+{
+public:
+    explicit ConsoleVisitor(std::ostream& out = std::cerr);
+    // overrides all six InspectVisitor methods
+};
+
+/// Inspect a single registered class by its C++ type.
+/// Returns an empty ClassInspectInfo if T is not registered.
+template <class T>
+[[nodiscard]] ClassInspectInfo inspect(lua_State* L);
+
+/// Inspect a namespace by name. Pass nullptr or "" for the global namespace.
+/// Supports dotted paths (e.g. "Outer.Inner").
+/// Returns an empty NamespaceInspectInfo if the name is not found.
+[[nodiscard]] NamespaceInspectInfo inspectNamespace(lua_State* L, const char* namespaceName = nullptr);
+
+/// Traverse a NamespaceInspectInfo with a visitor.
+void accept(const NamespaceInspectInfo& ns, InspectVisitor& v);
+void accept(const ClassInspectInfo& cls,    InspectVisitor& v);
+
+/// Collect inspection data for a namespace and drive a visitor over it (convenience wrapper).
+void inspectAccept(lua_State* L, const char* namespaceName, InspectVisitor& visitor);
+
+/// Attach Lua parameter name hints to a function for use with addFunction / addStaticFunction.
+/// Works with and without LUABRIDGE_ENABLE_REFLECT. Hints are stored at runtime; type capture
+/// requires the macro.
+template <class F, class... Names>
+[[nodiscard]] FunctionWithHints<std::decay_t<F>> withHints(F&& func, Names&&... paramNames);
+```

From 572d45e6e46d1835ef71d4d9684e7ab501dedeac Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Wed, 8 Apr 2026 00:48:25 +0200
Subject: [PATCH 09/14] Better manual

---
 Manual.md | 1033 +++++++++++++++++++++++++++--------------------------
 1 file changed, 519 insertions(+), 514 deletions(-)

diff --git a/Manual.md b/Manual.md
index 51a710a6..913e867c 100644
--- a/Manual.md
+++ b/Manual.md
@@ -45,19 +45,6 @@ Contents
     *   [2.8 - Lua Stack](#28---lua-stack)
         *   [2.8.1 - Enums](#281---enums)
         *   [2.8.2 - lua_State](#282---lua_state)
-    *   [2.9 - C++20 Coroutine Integration](#29---c20-coroutine-integration)
-        *   [2.9.1 - CppCoroutine\<R\> - Generators callable from Lua](#291---cppcoroutiner----generators-callable-from-lua)
-        *   [2.9.2 - Accepting Arguments](#292---accepting-arguments)
-        *   [2.9.3 - Class Coroutines - Static and Member](#293---class-coroutines----static-and-member)
-        *   [2.9.4 - LuaCoroutine - Awaiting a Lua Thread from C++](#294---luacoroutine----awaiting-a-lua-thread-from-c)
-        *   [2.9.5 - Limitations](#295---limitations)
-
-*   [2.10 - Inspecting Registrations](#210---inspecting-registrations)
-
-    *   [2.10.1 - inspect\<T\> and inspectNamespace](#2101---inspectT-and-inspectnamespace)
-    *   [2.10.2 - Visitor API](#2102---visitor-api)
-    *   [2.10.3 - ConsoleVisitor](#2103---consolevisitor)
-    *   [2.10.4 - Enabling Full Type Information (LUABRIDGE_ENABLE_REFLECT)](#2104---enabling-full-type-information-luabridge_enable_reflect)
 
 *   [3 - Passing Objects](#3---passing-objects)
 
@@ -82,17 +69,31 @@ Contents
         *   [4.3.2 - Class LuaException](#432---class-luaexception)
         *   [4.3.3 - Calling with Error Handlers](#433---calling-with-error-handlers)
     *   [4.4 - Wrapping C++ Callables](#44---wrapping-c-callables)
+        *   [4.4.1 - LuaFunction\<Signature\>](#441---luafunctionsignature)
+    *   [4.5 - C++20 Coroutine Integration](#45---c20-coroutine-integration)
+        *   [4.5.1 - CppCoroutine\<R\> - Generators callable from Lua](#451---cppcoroutiner----generators-callable-from-lua)
+        *   [4.5.2 - Accepting Arguments](#452---accepting-arguments)
+        *   [4.5.3 - Class Coroutines - Static and Member](#453---class-coroutines----static-and-member)
+        *   [4.5.4 - LuaCoroutine - Awaiting a Lua Thread from C++](#454---luacoroutine----awaiting-a-lua-thread-from-c)
+        *   [4.5.5 - Limitations](#455---limitations)
 
 *   [5 - Security](#5---security)
 
-*   [6 - Configuration](#6---configuration)
+*   [6 - Inspecting Registrations](#6---inspecting-registrations)
+
+    *   [6.1 - inspect\<T\> and inspectNamespace](#61---inspectT-and-inspectnamespace)
+    *   [6.2 - Visitor API](#62---visitor-api)
+    *   [6.3 - ConsoleVisitor](#63---consolevisitor)
+    *   [6.4 - Enabling Full Type Information (LUABRIDGE_ENABLE_REFLECT)](#64---enabling-full-type-information-luabridge_enable_reflect)
+
+*   [7 - Configuration](#7---configuration)
 
-    * [6.1 - LUABRIDGE_SAFE_STACK_CHECKS](#61---luabridge-safe-stack-checks)
-    * [6.2 - LUABRIDGE_STRICT_STACK_CONVERSIONS](#62---luabridge-strict-stack-conversions)
-    * [6.3 - LUABRIDGE_SAFE_LUA_C_EXCEPTION_HANDLING](#63---luabridge-safe-c-exception-handling)
-    * [6.4 - LUABRIDGE_RAISE_UNREGISTERED_CLASS_USAGE](#64---luabridge-raise-unregistered-class-usage)
-    * [6.5 - LUABRIDGE_HAS_CXX20_COROUTINES / LUABRIDGE_DISABLE_CXX20_COROUTINES](#65---luabridge-has-cxx20-coroutines--luabridge-disable-cxx20-coroutines)
-    * [6.6 - LUABRIDGE_ENABLE_REFLECT](#66---luabridge-enable-reflect)
+    * [7.1 - LUABRIDGE_SAFE_STACK_CHECKS](#71---luabridge-safe-stack-checks)
+    * [7.2 - LUABRIDGE_STRICT_STACK_CONVERSIONS](#72---luabridge-strict-stack-conversions)
+    * [7.3 - LUABRIDGE_SAFE_LUA_C_EXCEPTION_HANDLING](#73---luabridge-safe-c-exception-handling)
+    * [7.4 - LUABRIDGE_RAISE_UNREGISTERED_CLASS_USAGE](#74---luabridge-raise-unregistered-class-usage)
+    * [7.5 - LUABRIDGE_HAS_CXX20_COROUTINES / LUABRIDGE_DISABLE_CXX20_COROUTINES](#75---luabridge-has-cxx20-coroutines--luabridge-disable-cxx20-coroutines)
+    * [7.6 - LUABRIDGE_ENABLE_REFLECT](#76---luabridge-enable-reflect)
 
 *   [Appendix - API Reference](#appendix---api-reference)
 
@@ -670,7 +671,7 @@ Special attention needs to be given to the order (priority) of the overloads, ba
 
 ### 2.5.2 - Parameter Name Hints
 
-When `LUABRIDGE_ENABLE_REFLECT` is defined (see [6.6](#66---luabridge-enable-reflect)), LuaBridge captures the C++ type names of function parameters at compile time. You can additionally attach human-readable **parameter name hints** to any function using `luabridge::withHints`. These names are stored alongside the function and become available through the [Inspection API](#210---inspecting-registrations).
+When `LUABRIDGE_ENABLE_REFLECT` is defined (see [6.6](#76---luabridge-enable-reflect)), LuaBridge captures the C++ type names of function parameters at compile time. You can additionally attach human-readable **parameter name hints** to any function using `luabridge::withHints`. These names are stored alongside the function and become available through the [Inspection API](#6---inspecting-registrations).
 
 ```cpp
 #define LUABRIDGE_ENABLE_REFLECT
@@ -1295,492 +1296,189 @@ When the script calls `useStateAndArgs`, it passes only the integer and string p
 
 The same is applicable for properties.
 
-2.9 - C++20 Coroutine Integration
-----------------------------------
+3 - Passing Objects
+===================
 
-LuaBridge3 provides first-class interoperability between C++20 coroutines and Lua coroutines, available when compiling with C++20 or later and Lua 5.2+ (requires `lua_yieldk`). The feature is guarded by `LUABRIDGE_HAS_CXX20_COROUTINES`, which is detected automatically and can be suppressed with `LUABRIDGE_DISABLE_CXX20_COROUTINES`.
+An object of a registered class `T` may be passed to Lua as:
 
-> **Note:** C++20 coroutine integration is not supported on Lua 5.1, LuaJIT, or Luau (those targets lack a public `lua_yieldk` equivalent).
+**`T`**
 
-### 2.9.1 - CppCoroutine\<R\> - Generators callable from Lua
+Passed by value (a copy), with _Lua lifetime_.
 
-`luabridge::CppCoroutine<R>` is a coroutine return type that bridges C++20 coroutines with Lua's `coroutine.wrap` / `coroutine.resume` API. A function returning `CppCoroutine<R>` can use `co_yield` to suspend and pass a value back to Lua, and `co_return` to finish and return a final value.
+**`const T`**
 
-Register via `Namespace::addCoroutine`:
+Passed by value (a copy), with _Lua lifetime_.
 
-```cpp
-luabridge::getGlobalNamespace(L)
-    .addCoroutine("range", [](int from, int to) -> luabridge::CppCoroutine<int>
-    {
-        for (int i = from; i <= to; ++i)
-            co_yield i;
-        co_return -1;  // sentinel value when the range is exhausted
-    });
-```
+**`T*`**
 
-From Lua, use `coroutine.wrap` to create a callable iterator:
+Passed by reference, with _C++ lifetime_.
 
-```lua
-local gen = coroutine.wrap(range)
-local v = gen(1, 5)   -- first call passes arguments; yields 1
-while v ~= -1 do
-    print(v)          -- 1, 2, 3, 4, 5
-    v = gen()         -- subsequent calls resume without arguments
-end
-```
+**`T&`**
 
-`CppCoroutine<void>` is also supported for coroutines that produce no values:
+Passed by reference, with _C++ lifetime_.
 
-```cpp
-.addCoroutine("doWork", []() -> luabridge::CppCoroutine<void>
-{
-    performStep1();
-    co_return;
-});
-```
+**`const T*`**
 
-An abandoned coroutine (one that goes out of scope in Lua without being fully consumed) is automatically cleaned up by the Lua garbage collector - no manual resource management is needed.
+Passed by const reference, with _C++ lifetime_.
 
-### 2.9.2 - Accepting Arguments
+**`const T&`**
 
-The factory lambda receives the Lua call arguments on first invocation. A `lua_State*` parameter, if present, must be the **first** parameter and receives the running Lua thread:
+Passed by const reference, with _C++ lifetime_.
+
+3.1 - C++ Lifetime
+------------------
+
+The creation and deletion of objects with _C++ lifetime_ is controlled by the C++ code. Lua does nothing when it garbage collects a reference to such an object. Specifically, the object's destructor is not called (since C++ owns it). Care must be taken to ensure that objects with C++ lifetime are not deleted while still being referenced by a `lua_State*`, or else undefined behavior results. In the previous examples, an instance of `A` can be passed to Lua with C++ lifetime, like this:
 
 ```cpp
-.addCoroutine("adder", [](int a, int b) -> luabridge::CppCoroutine<int>
-{
-    co_yield a + b;   // first resume yields the sum
-    co_return a * b;  // second resume returns the product
-});
+A a;
+
+auto result = luabridge::push (L, &a);              // pointer to 'a', C++ lifetime
+lua_setglobal (L, "a");
+
+auto result = luabridge::push (L, (const A*) &a);   // pointer to 'a const', C++ lifetime
+lua_setglobal (L, "ac");
+
+auto result = luabridge::push <const A*> (L, &a);   // equivalent to push (L, (A const*) &a)
+lua_setglobal (L, "ac2");
+
+auto result = luabridge::push (L, new A);           // compiles, but will leak memory
+lua_setglobal (L, "ap");
 ```
 
-```lua
-local f = coroutine.wrap(adder)
-print(f(3, 4))   -- 7   (yield: 3+4)
-print(f())       -- 12  (return: 3*4)
+3.2 - Lua Lifetime
+------------------
+
+When an object of a registered class is passed by value to Lua, it will have _Lua lifetime_. A copy of the passed object is constructed inside the userdata. When Lua has no more references to the object, it becomes eligible for garbage collection. When the userdata is collected, the destructor for the class will be called on the object. Care must be taken to ensure that objects with Lua lifetime are not accessed by C++ after they are garbage collected, or else undefined behavior results. An instance of `B` can be passed to Lua with Lua lifetime this way:
+
+```cpp
+B b;
+
+auto result = luabridge::push (L, b);  // Copy of b passed, Lua lifetime.
+lua_setglobal (L, "b");
 ```
 
-Multiple independent instances of the same coroutine factory can run concurrently - each call to `coroutine.wrap(name)` creates a separate C++ coroutine frame:
+Given the previous code segments, these Lua statements are applicable:
 
 ```lua
-local a = coroutine.wrap(adder)
-local b = coroutine.wrap(adder)
-a(1, 2)   -- independent from b
-b(10, 20)
+print (test.A.staticData)       -- Prints the static data member.
+print (test.A.staticProperty)   -- Prints the static property member.
+test.A.staticFunc ()            -- Calls the static method.
+
+print (a.data)                  -- Prints the data member.
+print (a.prop)                  -- Prints the property member.
+a:func1 ()                      -- Calls A::func1 ().
+test.A.func1 (a)                -- Equivalent to a:func1 ().
+test.A.func1 ("hello")          -- Error: "hello" is not a class A.
+a:virtualFunc ()                -- Calls A::virtualFunc ().
+
+print (b.data)                  -- Prints B::dataMember.
+print (b.prop)                  -- Prints inherited property member.
+b:func1 ()                      -- Calls B::func1 ().
+b:func2 ()                      -- Calls B::func2 ().
+test.B.func2 (a)                -- Error: a is not a class B.
+test.A.func1 (b)                -- Calls A::func1 ().
+b:virtualFunc ()                -- Calls B::virtualFunc ().
+test.B.virtualFunc (b)          -- Calls B::virtualFunc ().
+test.A.virtualFunc (b)          -- Calls B::virtualFunc ().
+test.B.virtualFunc (a)          -- Error: a is not a class B.
+
+a = nil; collectgarbage ()      -- 'a' still exists in C++.
+b = nil; collectgarbage ()      -- Lua calls ~B() on the copy of b.
 ```
 
-### 2.9.3 - Class Coroutines - Static and Member
+When Lua script creates an object of class type using a registered constructor, the resulting value will have Lua lifetime. After Lua no longer references the object, it becomes eligible for garbage collection. You can still pass these to C++, either by reference or by value. If passed by reference, the usual warnings apply about accessing the reference later, after it has been garbage collected.
 
-Coroutines can be attached directly to a registered class using `addStaticCoroutine` and `addCoroutine`.
+3.3 - Pointers, References, and Pass by Value
+---------------------------------------------
 
-**Static coroutines** behave identically to namespace-level coroutines but live in the class's static table. The factory requires no object argument:
+When C++ objects are passed from Lua back to C++ as arguments to functions, or set as data members, LuaBridge does its best to automate the conversion. Using the previous definitions, the following functions may be registered to Lua:
 
 ```cpp
-luabridge::getGlobalNamespace(L)
-    .beginClass<Counter>("Counter")
-        .addStaticCoroutine("range", [](int from, int count) -> luabridge::CppCoroutine<int>
-        {
-            for (int i = 0; i < count; ++i)
-                co_yield from + i;
-            co_return -1;
-        })
-    .endClass();
+void func0 (A a);
+void func1 (A* a);
+void func2 (A const* a);
+void func3 (A& a);
+void func4 (A const& a);
 ```
 
+Executing this Lua code will have the prescribed effect:
+
 ```lua
-local f = coroutine.wrap(Counter.range)
-print(f(5, 3))   -- 5  (first yield)
-print(f())       -- 6
-print(f())       -- 7
-print(f())       -- -1 (done)
+func0 (a)   -- Passes a copy of a, using A's copy constructor.
+func1 (a)   -- Passes a pointer to a.
+func2 (a)   -- Passes a pointer to a const a.
+func3 (a)   -- Passes a reference to a.
+func4 (a)   -- Passes a reference to a const a.
 ```
 
-**Member coroutines** bind a coroutine factory to individual class instances. The factory's **first argument must be `T*` or `const T*`** - LuaBridge passes the Lua object as that argument automatically:
+In the example above, all functions can read the data members and property members of `a`, or call const member functions of `a`. Only `func0`, `func1`, and `func3` can modify the data members and data properties, or call non-const member functions of `a`.
+
+The usual C++ inheritance and pointer assignment rules apply. Given:
 
 ```cpp
-.beginClass<Counter>("Counter")
-    .addCoroutine("generate", [](Counter* obj, int n) -> luabridge::CppCoroutine<int>
-    {
-        for (int i = 0; i < n; ++i)
-        {
-            co_yield obj->value;
-            obj->increment();
-        }
-        co_return -1;
-    })
-.endClass();
+void func5 (B b);
+void func6 (B* b);
 ```
 
+These Lua statements hold:
+
 ```lua
-local obj = Counter()
-local f = coroutine.wrap(Counter.generate)
-print(f(obj, 3))   -- 0  (obj.value before first increment)
-print(f())         -- 1
-print(f())         -- 2
-print(f())         -- -1 (done)
+func5 (b)   -- Passes a copy of b, using B's copy constructor.
+func6 (b)   -- Passes a pointer to b.
+func6 (a)   -- Error: Pointer to B expected.
+func1 (b)   -- Okay, b is a subclass of a.
 ```
 
-**Const vs non-const:** a factory that takes `const T*` as its first argument is registered as a const method - accessible on both const and non-const objects (it appears in both the const and non-const class tables). A factory taking `T*` is registered as a non-const method and is accessible on non-const objects only.
+When a pointer or pointer to const is passed to Lua and the pointer is null (zero), LuaBridge will pass Lua a `nil` instead. When Lua passes a `nil` to C++ where a pointer is expected, a null (zero) is passed instead. Attempting to pass a null pointer to a C++ function expecting a reference results in `lua_error` being called.
 
-```cpp
-// Accessible on const and non-const objects:
-.addCoroutine("peek", [](const Counter* obj) -> luabridge::CppCoroutine<int>
-{
-    co_yield obj->value;
-    co_return obj->value * 2;
-})
+3.4 - Shared Lifetime
+---------------------
 
-// Accessible on non-const objects only:
-.addCoroutine("pop", [](Counter* obj) -> luabridge::CppCoroutine<int>
-{
-    co_yield obj->value--;
-    co_return obj->value;
-})
-```
+LuaBridge supports a _shared lifetime_ model: dynamically allocated and reference counted objects whose ownership is shared by both Lua and C++. The object remains in existence until there are no remaining C++ or Lua references, and Lua performs its usual garbage collection cycle. A container is recognized by a specialization of the `ContainerTraits` template class. LuaBridge will automatically recognize when a data type is a container when the corresponding specialization is present. Two styles of containers come with LuaBridge, including the necessary specializations.
 
-### 2.9.4 - LuaCoroutine - Awaiting a Lua Thread from C++
+### 3.4.1 - User-defined Containers
 
-`luabridge::LuaCoroutine` is an awaitable that can be used inside a `CppCoroutine` body to resume a child Lua thread synchronously. It runs the child thread to its first yield or return and gives back the status and the number of values the child left on its stack:
+If you have your own container, you must provide a specialization of `luabridge::ContainerTraits` in the `luabridge` namespace for your type before it will be recognized by LuaBridge (or else the code will not compile):
 
 ```cpp
-.addCoroutine("driver", [](lua_State* L) -> luabridge::CppCoroutine<int>
-{
-    // Spawn a child Lua thread and anchor it in the registry so the GC
-    // doesn't collect it while we hold a pointer to it.
-    lua_State* child = lua_newthread(L);
-    int ref = luaL_ref(L, LUA_REGISTRYINDEX);  // pops thread from L's stack
+namespace luabridge {
 
-    lua_getglobal(child, "luaGenerator");
+template <class T>
+struct ContainerTraits<CustomContainer<T>>
+{
+  using Type = T;
 
-    // Resume the child synchronously; suspends this C++ coroutine until done.
-    auto [status, nresults] = co_await luabridge::LuaCoroutine{ child, L };
+  static CustomContainer<T> construct (T* c)
+  {
+    return c;
+  }
 
-    int value = (nresults > 0) ? static_cast<int>(lua_tointeger(child, -nresults)) : 0;
+  static T* get (const CustomContainer<T>& c)
+  {
+    return c.getPointerToObject ();
+  }
+};
 
-    luaL_unref(L, LUA_REGISTRYINDEX, ref);
-    co_return value;
-});
+} // namespace luabridge
 ```
 
-`LuaCoroutine` always completes synchronously (no external event loop is required). The `status` field contains `LUA_YIELD` if the child yielded or `LUA_OK` if it returned normally.
-
-### 2.9.5 - Limitations
-
-* **Lua version:** Requires Lua 5.2+ (`lua_yieldk`). Not supported on Lua 5.1, LuaJIT, or Luau.
-* **C++ version:** Requires C++20 (`<coroutine>`). Non-coroutine features continue to work under C++17.
-* **Multi-value yield:** `co_yield` sends exactly one value per suspension. Use `std::tuple` or a struct if multiple values are needed.
-* **Thread safety:** Coroutine frames must be driven from a single OS thread.
+Containers must be safely constructible from raw pointers to objects that are already referenced by other instances of the container (such as is the case for the provided containers or for example `boost::intrusive_ptr` but not `std::shared_ptr` or `boost::shared_ptr`).
 
-2.10 - Inspecting Registrations
-================================
+### 3.4.2 - shared_ptr As Container
 
-LuaBridge3 can introspect its own registration tables at runtime, making it straightforward to generate documentation, build IDE auto-complete databases, produce TypeScript type declarations, or validate that a binding matches an expected schema.
+Standard containers like `std::shared_ptr` or `boost::shared_ptr` will work in LuaBridge3, but they require special care. This is because of type erasure; when the object goes from C++ to Lua and back to C++, constructing a new shared_ptr from the raw pointer will create another reference count and result in undefined behavior, unless it could intrusively reconstruct the container from a raw pointer.
 
-The inspection API lives in the **optional** header `<LuaBridge/Inspect.h>`, which must be included separately and **requires** `LUABRIDGE_ENABLE_REFLECT` to be defined (see [6.6](#66---luabridge-enable-reflect)).
+To overcome this issue classes that should be managed by `shared_ptr` have to provide a way to correctly reconstruct a `shared_ptr` which can be done only if type hold it is deriving publicly from `std::enable_shared_from_this` or `boost::enable_shared_from_this`. No additional specialization of traits is needed in this case.
 
 ```cpp
-#define LUABRIDGE_ENABLE_REFLECT
-#include <LuaBridge/LuaBridge.h>
-#include <LuaBridge/Inspect.h>
-```
-
-### 2.10.1 - inspect\<T\> and inspectNamespace
-
-Two top-level free functions collect inspection data without traversing any Lua tables from user code:
+struct A : public std::enable_shared_from_this<A>
+{
+  A () { }
+  A (int) { }
 
-**`inspect<T>(L)`** — returns a `ClassInspectInfo` for the single registered class `T`. Returns an empty struct if `T` has not been registered.
-
-```cpp
-auto info = luabridge::inspect<Enemy>(L);
-std::cout << info.name << "\n"; // "Enemy"
-for (const auto& m : info.members)
-    std::cout << "  " << m.name << "\n";
-```
-
-**`inspectNamespace(L, name)`** — returns a `NamespaceInspectInfo` for the given namespace. Pass `nullptr` or an empty string to inspect the global namespace `_G`. Dotted paths are supported.
-
-```cpp
-auto ns  = luabridge::inspectNamespace(L, "game");       // top-level namespace
-auto sub = luabridge::inspectNamespace(L, "game.util");  // nested namespace
-auto g   = luabridge::inspectNamespace(L);               // global namespace (_G)
-```
-
-The returned structures are plain data — they are independent copies that do not hold references to the Lua state:
-
-| Type | Fields |
-|------|--------|
-| `NamespaceInspectInfo` | `name`, `freeMembers`, `classes`, `subNamespaces` |
-| `ClassInspectInfo` | `name`, `baseClasses`, `members` |
-| `MemberInfo` | `name`, `kind` (`MemberKind`), `overloads` |
-| `OverloadInfo` | `returnType`, `params` (`vector<ParamInfo>`), `isConst` |
-| `ParamInfo` | `typeName`, `hint` |
-
-`MemberKind` is an enum with the following values:
-
-```cpp
-enum class MemberKind
-{
-    Method,
-    StaticMethod,
-    Property,
-    ReadOnlyProperty,
-    StaticProperty,
-    StaticReadOnlyProperty,
-    Constructor,
-    Metamethod,
-};
-```
-
-`returnType` and `typeName` are populated only when `LUABRIDGE_ENABLE_REFLECT` is defined. `hint` is populated when the function was registered with `luabridge::withHints` (see [2.5.2](#252---parameter-name-hints)).
-
-### 2.10.2 - Visitor API
-
-For namespace-wide traversal, a visitor-pattern API is provided. Derive from `InspectVisitor` and override only the callbacks you need:
-
-```cpp
-class InspectVisitor
-{
-public:
-    virtual void beginNamespace(const NamespaceInspectInfo& ns) {}
-    virtual void endNamespace  (const NamespaceInspectInfo& ns) {}
-    virtual void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) {}
-
-    virtual void beginClass(const ClassInspectInfo& cls) {}
-    virtual void endClass  (const ClassInspectInfo& cls) {}
-    virtual void visitMember(const ClassInspectInfo& cls, const MemberInfo& m) {}
-};
-```
-
-Drive a visitor over a pre-collected `NamespaceInspectInfo` using `accept`, or use the convenience wrapper `inspectAccept` that collects and visits in one call:
-
-```cpp
-// Option A: collect once, visit multiple times
-auto ns = luabridge::inspectNamespace(L, "game");
-MyVisitor v;
-luabridge::accept(ns, v);
-
-// Option B: collect and visit in a single call
-luabridge::inspectAccept(L, "game", v);
-```
-
-The traversal order for `accept` is:
-1. `beginNamespace`
-2. `visitFreeMember` for each free function / namespace-level property
-3. Recursive traversal of each class (begin → members → end)
-4. Recursive traversal of each sub-namespace
-5. `endNamespace`
-
-### 2.10.3 - ConsoleVisitor
-
-LuaBridge provides a ready-made visitor, `ConsoleVisitor`, that prints a TypeScript-style declaration to any `std::ostream` (defaults to `std::cerr`):
-
-```cpp
-luabridge::ConsoleVisitor printer(std::cout);
-luabridge::inspectAccept(L, "game", printer);
-```
-
-Example output for a `game` namespace containing an `Enemy` class:
-
-```
-namespace game {
-    class Enemy {
-        constructor(p1: any);
-        attack(target: Enemy, damage: float): void;
-        move(x: float, y: float, z: float): void;
-        readonly hp: int;
-        static create(p1: float, p2: float): Enemy;
-    }
-}
-```
-
-Type names and parameter names are filled in when `LUABRIDGE_ENABLE_REFLECT` is active and `withHints` was used during registration. Without reflection the output uses `any` for unknown types and `p1`, `p2`, … as placeholder parameter names.
-
-### 2.10.4 - Enabling Full Type Information (LUABRIDGE_ENABLE_REFLECT)
-
-See [6.6 - LUABRIDGE_ENABLE_REFLECT](#66---luabridge-enable-reflect) for the compile-time flag that activates C++ type-name capture. When the flag is off, the inspection API still works — it just reports empty strings for type names. The `withHints` parameter name hints work regardless of the flag.
-
-3 - Passing Objects
-===================
-
-An object of a registered class `T` may be passed to Lua as:
-
-**`T`**
-
-Passed by value (a copy), with _Lua lifetime_.
-
-**`const T`**
-
-Passed by value (a copy), with _Lua lifetime_.
-
-**`T*`**
-
-Passed by reference, with _C++ lifetime_.
-
-**`T&`**
-
-Passed by reference, with _C++ lifetime_.
-
-**`const T*`**
-
-Passed by const reference, with _C++ lifetime_.
-
-**`const T&`**
-
-Passed by const reference, with _C++ lifetime_.
-
-3.1 - C++ Lifetime
-------------------
-
-The creation and deletion of objects with _C++ lifetime_ is controlled by the C++ code. Lua does nothing when it garbage collects a reference to such an object. Specifically, the object's destructor is not called (since C++ owns it). Care must be taken to ensure that objects with C++ lifetime are not deleted while still being referenced by a `lua_State*`, or else undefined behavior results. In the previous examples, an instance of `A` can be passed to Lua with C++ lifetime, like this:
-
-```cpp
-A a;
-
-auto result = luabridge::push (L, &a);              // pointer to 'a', C++ lifetime
-lua_setglobal (L, "a");
-
-auto result = luabridge::push (L, (const A*) &a);   // pointer to 'a const', C++ lifetime
-lua_setglobal (L, "ac");
-
-auto result = luabridge::push <const A*> (L, &a);   // equivalent to push (L, (A const*) &a)
-lua_setglobal (L, "ac2");
-
-auto result = luabridge::push (L, new A);           // compiles, but will leak memory
-lua_setglobal (L, "ap");
-```
-
-3.2 - Lua Lifetime
-------------------
-
-When an object of a registered class is passed by value to Lua, it will have _Lua lifetime_. A copy of the passed object is constructed inside the userdata. When Lua has no more references to the object, it becomes eligible for garbage collection. When the userdata is collected, the destructor for the class will be called on the object. Care must be taken to ensure that objects with Lua lifetime are not accessed by C++ after they are garbage collected, or else undefined behavior results. An instance of `B` can be passed to Lua with Lua lifetime this way:
-
-```cpp
-B b;
-
-auto result = luabridge::push (L, b);  // Copy of b passed, Lua lifetime.
-lua_setglobal (L, "b");
-```
-
-Given the previous code segments, these Lua statements are applicable:
-
-```lua
-print (test.A.staticData)       -- Prints the static data member.
-print (test.A.staticProperty)   -- Prints the static property member.
-test.A.staticFunc ()            -- Calls the static method.
-
-print (a.data)                  -- Prints the data member.
-print (a.prop)                  -- Prints the property member.
-a:func1 ()                      -- Calls A::func1 ().
-test.A.func1 (a)                -- Equivalent to a:func1 ().
-test.A.func1 ("hello")          -- Error: "hello" is not a class A.
-a:virtualFunc ()                -- Calls A::virtualFunc ().
-
-print (b.data)                  -- Prints B::dataMember.
-print (b.prop)                  -- Prints inherited property member.
-b:func1 ()                      -- Calls B::func1 ().
-b:func2 ()                      -- Calls B::func2 ().
-test.B.func2 (a)                -- Error: a is not a class B.
-test.A.func1 (b)                -- Calls A::func1 ().
-b:virtualFunc ()                -- Calls B::virtualFunc ().
-test.B.virtualFunc (b)          -- Calls B::virtualFunc ().
-test.A.virtualFunc (b)          -- Calls B::virtualFunc ().
-test.B.virtualFunc (a)          -- Error: a is not a class B.
-
-a = nil; collectgarbage ()      -- 'a' still exists in C++.
-b = nil; collectgarbage ()      -- Lua calls ~B() on the copy of b.
-```
-
-When Lua script creates an object of class type using a registered constructor, the resulting value will have Lua lifetime. After Lua no longer references the object, it becomes eligible for garbage collection. You can still pass these to C++, either by reference or by value. If passed by reference, the usual warnings apply about accessing the reference later, after it has been garbage collected.
-
-3.3 - Pointers, References, and Pass by Value
----------------------------------------------
-
-When C++ objects are passed from Lua back to C++ as arguments to functions, or set as data members, LuaBridge does its best to automate the conversion. Using the previous definitions, the following functions may be registered to Lua:
-
-```cpp
-void func0 (A a);
-void func1 (A* a);
-void func2 (A const* a);
-void func3 (A& a);
-void func4 (A const& a);
-```
-
-Executing this Lua code will have the prescribed effect:
-
-```lua
-func0 (a)   -- Passes a copy of a, using A's copy constructor.
-func1 (a)   -- Passes a pointer to a.
-func2 (a)   -- Passes a pointer to a const a.
-func3 (a)   -- Passes a reference to a.
-func4 (a)   -- Passes a reference to a const a.
-```
-
-In the example above, all functions can read the data members and property members of `a`, or call const member functions of `a`. Only `func0`, `func1`, and `func3` can modify the data members and data properties, or call non-const member functions of `a`.
-
-The usual C++ inheritance and pointer assignment rules apply. Given:
-
-```cpp
-void func5 (B b);
-void func6 (B* b);
-```
-
-These Lua statements hold:
-
-```lua
-func5 (b)   -- Passes a copy of b, using B's copy constructor.
-func6 (b)   -- Passes a pointer to b.
-func6 (a)   -- Error: Pointer to B expected.
-func1 (b)   -- Okay, b is a subclass of a.
-```
-
-When a pointer or pointer to const is passed to Lua and the pointer is null (zero), LuaBridge will pass Lua a `nil` instead. When Lua passes a `nil` to C++ where a pointer is expected, a null (zero) is passed instead. Attempting to pass a null pointer to a C++ function expecting a reference results in `lua_error` being called.
-
-3.4 - Shared Lifetime
----------------------
-
-LuaBridge supports a _shared lifetime_ model: dynamically allocated and reference counted objects whose ownership is shared by both Lua and C++. The object remains in existence until there are no remaining C++ or Lua references, and Lua performs its usual garbage collection cycle. A container is recognized by a specialization of the `ContainerTraits` template class. LuaBridge will automatically recognize when a data type is a container when the corresponding specialization is present. Two styles of containers come with LuaBridge, including the necessary specializations.
-
-### 3.4.1 - User-defined Containers
-
-If you have your own container, you must provide a specialization of `luabridge::ContainerTraits` in the `luabridge` namespace for your type before it will be recognized by LuaBridge (or else the code will not compile):
-
-```cpp
-namespace luabridge {
-
-template <class T>
-struct ContainerTraits<CustomContainer<T>>
-{
-  using Type = T;
-
-  static CustomContainer<T> construct (T* c)
-  {
-    return c;
-  }
-
-  static T* get (const CustomContainer<T>& c)
-  {
-    return c.getPointerToObject ();
-  }
-};
-
-} // namespace luabridge
-```
-
-Containers must be safely constructible from raw pointers to objects that are already referenced by other instances of the container (such as is the case for the provided containers or for example `boost::intrusive_ptr` but not `std::shared_ptr` or `boost::shared_ptr`).
-
-### 3.4.2 - shared_ptr As Container
-
-Standard containers like `std::shared_ptr` or `boost::shared_ptr` will work in LuaBridge3, but they require special care. This is because of type erasure; when the object goes from C++ to Lua and back to C++, constructing a new shared_ptr from the raw pointer will create another reference count and result in undefined behavior, unless it could intrusively reconstruct the container from a raw pointer.
-
-To overcome this issue classes that should be managed by `shared_ptr` have to provide a way to correctly reconstruct a `shared_ptr` which can be done only if type hold it is deriving publicly from `std::enable_shared_from_this` or `boost::enable_shared_from_this`. No additional specialization of traits is needed in this case.
-
-```cpp
-struct A : public std::enable_shared_from_this<A>
-{
-  A () { }
-  A (int) { }
-
-  void foo () { }
-};
+  void foo () { }
+};
 
 luabridge::getGlobalNamespace (L)
   .beginClass<A> ("A")
@@ -2106,91 +1804,266 @@ When compiling `LuaBridge3` with exceptions disabled, all references to try catc
 
 ### 4.3.2 - Class LuaException
 
-When the application is compiled with exceptions and `luabridge::enableExceptions` function has been called, using `luabridge::call` or `LuaRef::operator()` will uses the C++ exception handling mechanism, throwing a `luabridge::LuaException` object in case an argument has a type that has not been registered (and cannot be pushed onto the lua stack) or the lua function generated an error:
+When the application is compiled with exceptions and `luabridge::enableExceptions` function has been called, using `luabridge::call` or `LuaRef::operator()` will uses the C++ exception handling mechanism, throwing a `luabridge::LuaException` object in case an argument has a type that has not been registered (and cannot be pushed onto the lua stack) or the lua function generated an error:
+
+```lua
+function fail ()
+  error ("A problem occurred")
+end
+```
+
+```cpp
+luabridge::LuaRef f = luabridge::getGlobal (L, "fail");
+
+try
+{
+  f ();
+}
+catch (const luabridge::LuaException& e)
+{
+  std::cerr << e.what ();
+}
+```
+
+### 4.3.3 - Calling with Error Handlers
+
+By default, when a Lua error occurs the raw Lua error message is stored in the `TypeResult`. For more detailed diagnostics you can supply a custom message handler (equivalent to the `msgh` parameter of `lua_pcall`). The handler is a C++ callable that receives a `lua_State*`, may inspect the stack, and must return an `int`:
+
+```lua
+function riskyOp ()
+  error ("something went wrong")
+end
+```
+
+```cpp
+luabridge::LuaRef f = luabridge::getGlobal (L, "riskyOp");
+
+auto handler = [] (lua_State* L) -> int {
+  // Augment the error message with a traceback
+  luaL_traceback (L, L, lua_tostring (L, 1), 1);
+  return 1;
+};
+
+auto result = f.callWithHandler (handler);
+if (! result)
+  std::cerr << result.message ();  // includes traceback
+```
+
+The same function is available as a free function:
+
+```cpp
+auto result = luabridge::callWithHandler (f, handler, /* args... */);
+```
+
+4.4 - Wrapping C++ Callables
+-----------------------------
+
+`luabridge::newFunction` (and its equivalent `LuaRef::newFunction`) wraps any C++ callable - a lambda, a function pointer, or a `std::function` - into a Lua function and returns it as a `LuaRef`. This is useful when you need to pass a C++ callback to Lua without going through the namespace/class registration API:
+
+```cpp
+// Create a Lua function that squares its argument
+luabridge::LuaRef square = luabridge::newFunction (L, [] (int x) { return x * x; });
+
+// Store it in a Lua global
+luabridge::setGlobal (L, square, "square");
+```
+
+From Lua:
+```lua
+print (square (5))  -- 25
+```
+
+You can also store such a function in a table or pass it as a callback argument.
+
+### 4.4.1 - LuaFunction\<Signature\>
+
+When you have a `LuaRef` that you know will always be called with fixed argument and return types, `LuaFunction<Signature>` provides a strongly-typed wrapper that avoids repeating the template arguments at every call site:
+
+```cpp
+// Retrieve a Lua function and wrap it with a known signature
+auto add = luabridge::getGlobal (L, "add").callable<int(int, int)>();
+
+auto result = add (3, 4);  // TypeResult<int>
+if (result)
+  std::cout << *result;    // 7
+```
+
+`LuaFunction<Signature>` supports the same `call`, `callWithHandler`, and `isValid` interface as a `LuaRef`. The wrapped `LuaRef` is accessible via `ref()`.
+
+4.5 - C++20 Coroutine Integration
+----------------------------------
+
+LuaBridge3 provides first-class interoperability between C++20 coroutines and Lua coroutines, available when compiling with C++20 or later and Lua 5.2+ (requires `lua_yieldk`). The feature is guarded by `LUABRIDGE_HAS_CXX20_COROUTINES`, which is detected automatically and can be suppressed with `LUABRIDGE_DISABLE_CXX20_COROUTINES`.
+
+> **Note:** C++20 coroutine integration is not supported on Lua 5.1, LuaJIT, or Luau (those targets lack a public `lua_yieldk` equivalent).
+
+### 4.5.1 - CppCoroutine\<R\> - Generators callable from Lua
+
+`luabridge::CppCoroutine<R>` is a coroutine return type that bridges C++20 coroutines with Lua's `coroutine.wrap` / `coroutine.resume` API. A function returning `CppCoroutine<R>` can use `co_yield` to suspend and pass a value back to Lua, and `co_return` to finish and return a final value.
+
+Register via `Namespace::addCoroutine`:
+
+```cpp
+luabridge::getGlobalNamespace(L)
+    .addCoroutine("range", [](int from, int to) -> luabridge::CppCoroutine<int>
+    {
+        for (int i = from; i <= to; ++i)
+            co_yield i;
+        co_return -1;  // sentinel value when the range is exhausted
+    });
+```
+
+From Lua, use `coroutine.wrap` to create a callable iterator:
+
+```lua
+local gen = coroutine.wrap(range)
+local v = gen(1, 5)   -- first call passes arguments; yields 1
+while v ~= -1 do
+    print(v)          -- 1, 2, 3, 4, 5
+    v = gen()         -- subsequent calls resume without arguments
+end
+```
+
+`CppCoroutine<void>` is also supported for coroutines that produce no values:
+
+```cpp
+.addCoroutine("doWork", []() -> luabridge::CppCoroutine<void>
+{
+    performStep1();
+    co_return;
+});
+```
+
+An abandoned coroutine (one that goes out of scope in Lua without being fully consumed) is automatically cleaned up by the Lua garbage collector - no manual resource management is needed.
+
+### 4.5.2 - Accepting Arguments
+
+The factory lambda receives the Lua call arguments on first invocation. A `lua_State*` parameter, if present, must be the **first** parameter and receives the running Lua thread:
+
+```cpp
+.addCoroutine("adder", [](int a, int b) -> luabridge::CppCoroutine<int>
+{
+    co_yield a + b;   // first resume yields the sum
+    co_return a * b;  // second resume returns the product
+});
+```
+
+```lua
+local f = coroutine.wrap(adder)
+print(f(3, 4))   -- 7   (yield: 3+4)
+print(f())       -- 12  (return: 3*4)
+```
+
+Multiple independent instances of the same coroutine factory can run concurrently - each call to `coroutine.wrap(name)` creates a separate C++ coroutine frame:
 
 ```lua
-function fail ()
-  error ("A problem occurred")
-end
+local a = coroutine.wrap(adder)
+local b = coroutine.wrap(adder)
+a(1, 2)   -- independent from b
+b(10, 20)
 ```
 
-```cpp
-luabridge::LuaRef f = luabridge::getGlobal (L, "fail");
+### 4.5.3 - Class Coroutines - Static and Member
 
-try
-{
-  f ();
-}
-catch (const luabridge::LuaException& e)
-{
-  std::cerr << e.what ();
-}
-```
+Coroutines can be attached directly to a registered class using `addStaticCoroutine` and `addCoroutine`.
 
-### 4.3.3 - Calling with Error Handlers
+**Static coroutines** behave identically to namespace-level coroutines but live in the class's static table. The factory requires no object argument:
 
-By default, when a Lua error occurs the raw Lua error message is stored in the `TypeResult`. For more detailed diagnostics you can supply a custom message handler (equivalent to the `msgh` parameter of `lua_pcall`). The handler is a C++ callable that receives a `lua_State*`, may inspect the stack, and must return an `int`:
+```cpp
+luabridge::getGlobalNamespace(L)
+    .beginClass<Counter>("Counter")
+        .addStaticCoroutine("range", [](int from, int count) -> luabridge::CppCoroutine<int>
+        {
+            for (int i = 0; i < count; ++i)
+                co_yield from + i;
+            co_return -1;
+        })
+    .endClass();
+```
 
 ```lua
-function riskyOp ()
-  error ("something went wrong")
-end
+local f = coroutine.wrap(Counter.range)
+print(f(5, 3))   -- 5  (first yield)
+print(f())       -- 6
+print(f())       -- 7
+print(f())       -- -1 (done)
 ```
 
-```cpp
-luabridge::LuaRef f = luabridge::getGlobal (L, "riskyOp");
+**Member coroutines** bind a coroutine factory to individual class instances. The factory's **first argument must be `T*` or `const T*`** - LuaBridge passes the Lua object as that argument automatically:
 
-auto handler = [] (lua_State* L) -> int {
-  // Augment the error message with a traceback
-  luaL_traceback (L, L, lua_tostring (L, 1), 1);
-  return 1;
-};
+```cpp
+.beginClass<Counter>("Counter")
+    .addCoroutine("generate", [](Counter* obj, int n) -> luabridge::CppCoroutine<int>
+    {
+        for (int i = 0; i < n; ++i)
+        {
+            co_yield obj->value;
+            obj->increment();
+        }
+        co_return -1;
+    })
+.endClass();
+```
 
-auto result = f.callWithHandler (handler);
-if (! result)
-  std::cerr << result.message ();  // includes traceback
+```lua
+local obj = Counter()
+local f = coroutine.wrap(Counter.generate)
+print(f(obj, 3))   -- 0  (obj.value before first increment)
+print(f())         -- 1
+print(f())         -- 2
+print(f())         -- -1 (done)
 ```
 
-The same function is available as a free function:
+**Const vs non-const:** a factory that takes `const T*` as its first argument is registered as a const method - accessible on both const and non-const objects (it appears in both the const and non-const class tables). A factory taking `T*` is registered as a non-const method and is accessible on non-const objects only.
 
 ```cpp
-auto result = luabridge::callWithHandler (f, handler, /* args... */);
+// Accessible on const and non-const objects:
+.addCoroutine("peek", [](const Counter* obj) -> luabridge::CppCoroutine<int>
+{
+    co_yield obj->value;
+    co_return obj->value * 2;
+})
+
+// Accessible on non-const objects only:
+.addCoroutine("pop", [](Counter* obj) -> luabridge::CppCoroutine<int>
+{
+    co_yield obj->value--;
+    co_return obj->value;
+})
 ```
 
-4.4 - Wrapping C++ Callables
------------------------------
+### 4.5.4 - LuaCoroutine - Awaiting a Lua Thread from C++
 
-`luabridge::newFunction` (and its equivalent `LuaRef::newFunction`) wraps any C++ callable - a lambda, a function pointer, or a `std::function` - into a Lua function and returns it as a `LuaRef`. This is useful when you need to pass a C++ callback to Lua without going through the namespace/class registration API:
+`luabridge::LuaCoroutine` is an awaitable that can be used inside a `CppCoroutine` body to resume a child Lua thread synchronously. It runs the child thread to its first yield or return and gives back the status and the number of values the child left on its stack:
 
 ```cpp
-// Create a Lua function that squares its argument
-luabridge::LuaRef square = luabridge::newFunction (L, [] (int x) { return x * x; });
-
-// Store it in a Lua global
-luabridge::setGlobal (L, square, "square");
-```
+.addCoroutine("driver", [](lua_State* L) -> luabridge::CppCoroutine<int>
+{
+    // Spawn a child Lua thread and anchor it in the registry so the GC
+    // doesn't collect it while we hold a pointer to it.
+    lua_State* child = lua_newthread(L);
+    int ref = luaL_ref(L, LUA_REGISTRYINDEX);  // pops thread from L's stack
 
-From Lua:
-```lua
-print (square (5))  -- 25
-```
+    lua_getglobal(child, "luaGenerator");
 
-You can also store such a function in a table or pass it as a callback argument.
+    // Resume the child synchronously; suspends this C++ coroutine until done.
+    auto [status, nresults] = co_await luabridge::LuaCoroutine{ child, L };
 
-### 4.4.1 - LuaFunction\<Signature\>
+    int value = (nresults > 0) ? static_cast<int>(lua_tointeger(child, -nresults)) : 0;
 
-When you have a `LuaRef` that you know will always be called with fixed argument and return types, `LuaFunction<Signature>` provides a strongly-typed wrapper that avoids repeating the template arguments at every call site:
+    luaL_unref(L, LUA_REGISTRYINDEX, ref);
+    co_return value;
+});
+```
 
-```cpp
-// Retrieve a Lua function and wrap it with a known signature
-auto add = luabridge::getGlobal (L, "add").callable<int(int, int)>();
+`LuaCoroutine` always completes synchronously (no external event loop is required). The `status` field contains `LUA_YIELD` if the child yielded or `LUA_OK` if it returned normally.
 
-auto result = add (3, 4);  // TypeResult<int>
-if (result)
-  std::cout << *result;    // 7
-```
+### 4.5.5 - Limitations
 
-`LuaFunction<Signature>` supports the same `call`, `callWithHandler`, and `isValid` interface as a `LuaRef`. The wrapped `LuaRef` is accessible via `ref()`.
+* **Lua version:** Requires Lua 5.2+ (`lua_yieldk`). Not supported on Lua 5.1, LuaJIT, or Luau.
+* **C++ version:** Requires C++20 (`<coroutine>`). Non-coroutine features continue to work under C++17.
+* **Multi-value yield:** `co_yield` sends exactly one value per suspension. Use `std::tuple` or a struct if multiple values are needed.
+* **Thread safety:** Coroutine frames must be driven from a single OS thread.
 
 5 - Security
 ============
@@ -2231,12 +2104,144 @@ luabridge::getGlobalNamespace (L)
   .endNamespace ()
 ```
 
-6 - Configuration
+6 - Inspecting Registrations
+============================
+
+LuaBridge3 can introspect its own registration tables at runtime, making it straightforward to generate documentation, build IDE auto-complete databases, produce TypeScript type declarations, or validate that a binding matches an expected schema.
+
+The inspection API lives in the **optional** header `<LuaBridge/Inspect.h>`, which must be included separately and **requires** `LUABRIDGE_ENABLE_REFLECT` to be defined (see [7.6](#76---luabridge-enable-reflect)).
+
+```cpp
+#define LUABRIDGE_ENABLE_REFLECT
+#include <LuaBridge/LuaBridge.h>
+#include <LuaBridge/Inspect.h>
+```
+
+6.1 - inspect\<T\> and inspectNamespace
+----------------------------------------
+
+Two top-level free functions collect inspection data without traversing any Lua tables from user code:
+
+**`inspect<T>(L)`** — returns a `ClassInspectInfo` for the single registered class `T`. Returns an empty struct if `T` has not been registered.
+
+```cpp
+auto info = luabridge::inspect<Enemy>(L);
+std::cout << info.name << "\n"; // "Enemy"
+for (const auto& m : info.members)
+    std::cout << "  " << m.name << "\n";
+```
+
+**`inspectNamespace(L, name)`** — returns a `NamespaceInspectInfo` for the given namespace. Pass `nullptr` or an empty string to inspect the global namespace `_G`. Dotted paths are supported.
+
+```cpp
+auto ns  = luabridge::inspectNamespace(L, "game");       // top-level namespace
+auto sub = luabridge::inspectNamespace(L, "game.util");  // nested namespace
+auto g   = luabridge::inspectNamespace(L);               // global namespace (_G)
+```
+
+The returned structures are plain data — they are independent copies that do not hold references to the Lua state:
+
+| Type | Fields |
+|------|--------|
+| `NamespaceInspectInfo` | `name`, `freeMembers`, `classes`, `subNamespaces` |
+| `ClassInspectInfo` | `name`, `baseClasses`, `members` |
+| `MemberInfo` | `name`, `kind` (`MemberKind`), `overloads` |
+| `OverloadInfo` | `returnType`, `params` (`vector<ParamInfo>`), `isConst` |
+| `ParamInfo` | `typeName`, `hint` |
+
+`MemberKind` is an enum with the following values:
+
+```cpp
+enum class MemberKind
+{
+    Method,
+    StaticMethod,
+    Property,
+    ReadOnlyProperty,
+    StaticProperty,
+    StaticReadOnlyProperty,
+    Constructor,
+    Metamethod,
+};
+```
+
+`returnType` and `typeName` are populated only when `LUABRIDGE_ENABLE_REFLECT` is defined. `hint` is populated when the function was registered with `luabridge::withHints` (see [2.5.2](#252---parameter-name-hints)).
+
+6.2 - Visitor API
+------------------
+
+For namespace-wide traversal, a visitor-pattern API is provided. Derive from `InspectVisitor` and override only the callbacks you need:
+
+```cpp
+class InspectVisitor
+{
+public:
+    virtual void beginNamespace(const NamespaceInspectInfo& ns) {}
+    virtual void endNamespace  (const NamespaceInspectInfo& ns) {}
+    virtual void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) {}
+
+    virtual void beginClass(const ClassInspectInfo& cls) {}
+    virtual void endClass  (const ClassInspectInfo& cls) {}
+    virtual void visitMember(const ClassInspectInfo& cls, const MemberInfo& m) {}
+};
+```
+
+Drive a visitor over a pre-collected `NamespaceInspectInfo` using `accept`, or use the convenience wrapper `inspectAccept` that collects and visits in one call:
+
+```cpp
+// Option A: collect once, visit multiple times
+auto ns = luabridge::inspectNamespace(L, "game");
+MyVisitor v;
+luabridge::accept(ns, v);
+
+// Option B: collect and visit in a single call
+luabridge::inspectAccept(L, "game", v);
+```
+
+The traversal order for `accept` is:
+1. `beginNamespace`
+2. `visitFreeMember` for each free function / namespace-level property
+3. Recursive traversal of each class (begin → members → end)
+4. Recursive traversal of each sub-namespace
+5. `endNamespace`
+
+6.3 - ConsoleVisitor
+---------------------
+
+LuaBridge provides a ready-made visitor, `ConsoleVisitor`, that prints a TypeScript-style declaration to any `std::ostream` (defaults to `std::cerr`):
+
+```cpp
+luabridge::ConsoleVisitor printer(std::cout);
+luabridge::inspectAccept(L, "game", printer);
+```
+
+Example output for a `game` namespace containing an `Enemy` class:
+
+```
+namespace game {
+    class Enemy {
+        constructor(p1: any);
+        attack(target: Enemy, damage: float): void;
+        move(x: float, y: float, z: float): void;
+        readonly hp: int;
+        static create(p1: float, p2: float): Enemy;
+    }
+}
+```
+
+Type names and parameter names are filled in when `LUABRIDGE_ENABLE_REFLECT` is active and `withHints` was used during registration. Without reflection the output uses `any` for unknown types and `p1`, `p2`, … as placeholder parameter names.
+
+6.4 - Enabling Full Type Information (LUABRIDGE_ENABLE_REFLECT)
+----------------------------------------------------------------
+
+See [7.6 - LUABRIDGE_ENABLE_REFLECT](#76---luabridge-enable-reflect) for the compile-time flag that activates C++ type-name capture. When the flag is off, the inspection API still works — it just reports empty strings for type names. The `withHints` parameter name hints work regardless of the flag.
+
+7 - Configuration
 =================
 
 LuaBridge3 exposes several compile-time configuration macros. Each macro can be overridden by defining it **before** including any LuaBridge header, or by passing it as a compiler flag (e.g. `-DLUABRIDGE_SAFE_STACK_CHECKS=0`).
 
-6.1 - LUABRIDGE_SAFE_STACK_CHECKS
+7.1 - LUABRIDGE_SAFE_STACK_CHECKS
 ----------------------------------
 
 **Default: `1` (enabled)**
@@ -2250,7 +2255,7 @@ Disable this flag only when you are certain that the Lua stack will never overfl
 #include <LuaBridge/LuaBridge.h>
 ```
 
-6.2 - LUABRIDGE_STRICT_STACK_CONVERSIONS
+7.2 - LUABRIDGE_STRICT_STACK_CONVERSIONS
 -----------------------------------------
 
 **Default: `0` (disabled)**
@@ -2288,7 +2293,7 @@ lua_pushboolean (L, 1);
 auto r = luabridge::Stack<bool>::get (L, -1); // ok: true
 ```
 
-6.3 - LUABRIDGE_SAFE_LUA_C_EXCEPTION_HANDLING
+7.3 - LUABRIDGE_SAFE_LUA_C_EXCEPTION_HANDLING
 -----------------------------------------------
 
 **Default: `0` (disabled). Only meaningful when `LUABRIDGE_HAS_EXCEPTIONS` is `1`.**
@@ -2304,7 +2309,7 @@ Enable this flag only if you are compiling Lua as C (not as C++), have exception
 
 > **Warning:** Enabling this flag introduces a small performance overhead on every registered CFunction call through the library.
 
-6.4 - LUABRIDGE_RAISE_UNREGISTERED_CLASS_USAGE
+7.4 - LUABRIDGE_RAISE_UNREGISTERED_CLASS_USAGE
 ------------------------------------------------
 
 **Default: `1` when exceptions are enabled, `0` otherwise.**
@@ -2318,7 +2323,7 @@ Override the default when you need fine-grained control:
 #include <LuaBridge/LuaBridge.h>
 ```
 
-6.5 - LUABRIDGE_HAS_CXX20_COROUTINES / LUABRIDGE_DISABLE_CXX20_COROUTINES
+7.5 - LUABRIDGE_HAS_CXX20_COROUTINES / LUABRIDGE_DISABLE_CXX20_COROUTINES
 --------------------------------------------------------------------------
 
 **`LUABRIDGE_HAS_CXX20_COROUTINES` - auto-detected, override allowed**
@@ -2342,12 +2347,12 @@ You can also override the detection result explicitly:
 
 Attempting to use coroutine integration on Lua 5.1, LuaJIT, or Luau will emit a compile-time `#error` unless `LUABRIDGE_DISABLE_COROUTINE_INTEGRATION` is also defined.
 
-6.6 - LUABRIDGE_ENABLE_REFLECT
+7.6 - LUABRIDGE_ENABLE_REFLECT
 -------------------------------
 
 **Default: not defined (disabled)**
 
-When defined, LuaBridge captures the C++ type names of function parameters and return types at compile time using `typeid`. This information is stored alongside the function in the Lua registry and is retrieved by the [Inspection API](#210---inspecting-registrations) to populate `OverloadInfo::returnType` and `ParamInfo::typeName`.
+When defined, LuaBridge captures the C++ type names of function parameters and return types at compile time using `typeid`. This information is stored alongside the function in the Lua registry and is retrieved by the [Inspection API](#6---inspecting-registrations) to populate `OverloadInfo::returnType` and `ParamInfo::typeName`.
 
 Enable reflection by defining the macro **before** including any LuaBridge header:
 

From 7f92ff6c3c4b3c9cfbc21722661bf3256a0d4e32 Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Wed, 8 Apr 2026 01:03:33 +0200
Subject: [PATCH 10/14] Update Manual.md

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 Manual.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Manual.md b/Manual.md
index 913e867c..31787e0e 100644
--- a/Manual.md
+++ b/Manual.md
@@ -671,7 +671,7 @@ Special attention needs to be given to the order (priority) of the overloads, ba
 
 ### 2.5.2 - Parameter Name Hints
 
-When `LUABRIDGE_ENABLE_REFLECT` is defined (see [6.6](#76---luabridge-enable-reflect)), LuaBridge captures the C++ type names of function parameters at compile time. You can additionally attach human-readable **parameter name hints** to any function using `luabridge::withHints`. These names are stored alongside the function and become available through the [Inspection API](#6---inspecting-registrations).
+When `LUABRIDGE_ENABLE_REFLECT` is defined (see [7.6](#76---luabridge-enable-reflect)), LuaBridge captures the C++ type names of function parameters at compile time. You can additionally attach human-readable **parameter name hints** to any function using `luabridge::withHints`. These names are stored alongside the function and become available through the [Inspection API](#6---inspecting-registrations).
 
 ```cpp
 #define LUABRIDGE_ENABLE_REFLECT

From 1e458c218ec87d833e0d00c7de5d9e55955889da Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Wed, 8 Apr 2026 01:03:46 +0200
Subject: [PATCH 11/14] Update Manual.md

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 Manual.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Manual.md b/Manual.md
index 31787e0e..8b0e7fd4 100644
--- a/Manual.md
+++ b/Manual.md
@@ -2365,7 +2365,7 @@ Enable reflection by defining the macro **before** including any LuaBridge heade
 > **Note:** `Inspect.h` unconditionally requires `LUABRIDGE_ENABLE_REFLECT` and will emit a `#error` if the macro is not defined. You may use `withHints` (see [2.5.2](#252---parameter-name-hints)) without including `Inspect.h`.
 
 When `LUABRIDGE_ENABLE_REFLECT` is not defined:
-* `withHints` parameter name hints are still stored and available through inspection.
+* `withHints` parameter name hints are ignored and are not available through inspection.
 * `OverloadInfo::returnType` and `ParamInfo::typeName` are empty strings.
 * The `Inspect.h` header cannot be included.
 

From 9d2876486d2644e87a2fb00d4e5e76e2120bcc9d Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Wed, 8 Apr 2026 01:04:21 +0200
Subject: [PATCH 12/14] Fix amalgama

---
 CMakeLists.txt                     |   2 +-
 Distribution/LuaBridge/LuaBridge.h | 397 +++++++++++++++++------------
 2 files changed, 232 insertions(+), 167 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1cf6acc8..dc1f1114 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,9 +13,9 @@ find_program (LCOV_EXECUTABLE lcov)
 find_program (GENHTML_EXECUTABLE genhtml)
 
 cmake_dependent_option (LUABRIDGE_TESTING "Build tests" ON "CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF)
-cmake_dependent_option (LUABRIDGE_SANITIZE "Sanitizer to enable (address, undefined, thread)" OFF "LUABRIDGE_TESTING" OFF)
 cmake_dependent_option (LUABRIDGE_COVERAGE "Enable coverage" OFF "LUABRIDGE_TESTING;FIND_EXECUTABLE;LCOV_EXECUTABLE;GENHTML_EXECUTABLE" OFF)
 cmake_dependent_option (LUABRIDGE_BENCHMARKS "Build benchmark executable" OFF "CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF)
+set (LUABRIDGE_SANITIZE "" CACHE STRING "Sanitizer to enable (address, undefined, thread)")
 
 add_subdirectory (Source)
 
diff --git a/Distribution/LuaBridge/LuaBridge.h b/Distribution/LuaBridge/LuaBridge.h
index dfb90ee7..7761c840 100644
--- a/Distribution/LuaBridge/LuaBridge.h
+++ b/Distribution/LuaBridge/LuaBridge.h
@@ -542,6 +542,27 @@ struct remove_first_type<std::tuple<T, Ts...>>
 template <class T>
 using remove_first_type_t = typename remove_first_type<T>::type;
 
+template <class Getter, class = void>
+struct getter_return_type
+{
+    using type = void;
+};
+
+template <class T, class C>
+struct getter_return_type<T C::*, std::enable_if_t<std::is_member_object_pointer_v<T C::*>>>
+{
+    using type = std::remove_const_t<T>;
+};
+
+template <class Getter>
+struct getter_return_type<Getter, std::enable_if_t<is_callable_v<Getter>>>
+{
+    using type = remove_cvref_t<function_result_t<Getter>>;
+};
+
+template <class Getter>
+using getter_return_t = typename getter_return_type<Getter>::type;
+
 } 
 } 
 
@@ -3263,6 +3284,11 @@ template <class T, auto = typeName<T>().find_first_of('.')>
     return reinterpret_cast<void*>(0xdad);
 }
 
+[[nodiscard]] inline const void* getPropTypeKey() noexcept
+{
+    return reinterpret_cast<void*>(0x9e7);
+}
+
 [[nodiscard]] inline const void* getCastTableKey() noexcept
 {
     return reinterpret_cast<void*>(0xca57);
@@ -7472,6 +7498,31 @@ inline void add_property_getter(lua_State* L, const char* name, int tableIndex)
     lua_pop(L, 2); 
 }
 
+inline void add_property_type(lua_State* L, const char* name, const char* typeName, int tableIndex)
+{
+#if LUABRIDGE_SAFE_STACK_CHECKS
+    luaL_checkstack(L, 3, detail::error_lua_stack_overflow);
+#endif
+
+    if (!typeName || typeName[0] == '\0')
+        return;
+
+    tableIndex = lua_absindex(L, tableIndex);
+
+    lua_rawgetp_x(L, tableIndex, getPropTypeKey()); 
+    if (lua_isnil(L, -1))
+    {
+        lua_pop(L, 1);
+        lua_createtable(L, 0, 4);
+        lua_pushvalue(L, -1);
+        lua_rawsetp_x(L, tableIndex, getPropTypeKey());
+    }
+    
+    lua_pushstring(L, typeName);
+    rawsetfield(L, -2, name);
+    lua_pop(L, 1); 
+}
+
 template <class T, class C = void>
 struct property_setter;
 
@@ -8966,6 +9017,10 @@ struct container_forwarder
 
 // Begin File: Source/LuaBridge/Inspect.h
 
+#if ! LUABRIDGE_ENABLE_REFLECT
+#error "This header is only for use when LUABRIDGE_ENABLE_REFLECT is active."
+#endif
+
 namespace luabridge {
 
 struct NamespaceInspectInfo;
@@ -9234,12 +9289,31 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
     }
     lua_pop(L, 1);
 
+    std::map<std::string, std::string> instPropTypes;
+    lua_rawgetp_x(L, clIdx, getPropTypeKey());
+    if (lua_istable(L, -1))
+    {
+        int ptIdx = lua_absindex(L, -1);
+        for (const auto& k : instPropget)
+        {
+            lua_getfield(L, ptIdx, k.c_str());
+            if (lua_isstring(L, -1))
+                instPropTypes[k] = lua_tostring(L, -1);
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1);
+
     for (const auto& propName : instPropget)
     {
         MemberInfo m;
         m.name = propName;
         m.kind = instPropsetReal.count(propName) ? MemberKind::Property : MemberKind::ReadOnlyProperty;
-        m.overloads.push_back(OverloadInfo{});
+        OverloadInfo ov;
+        auto it = instPropTypes.find(propName);
+        if (it != instPropTypes.end())
+            ov.returnType = it->second;
+        m.overloads.push_back(std::move(ov));
         cls.members.push_back(std::move(m));
     }
 
@@ -9293,12 +9367,31 @@ inline ClassInspectInfo inspectClassFromStaticTable(lua_State* L, int stIdx)
     }
     lua_pop(L, 1);
 
+    std::map<std::string, std::string> stPropTypes;
+    lua_rawgetp_x(L, mtIdx, getPropTypeKey());
+    if (lua_istable(L, -1))
+    {
+        int ptIdx = lua_absindex(L, -1);
+        for (const auto& k : stPropget)
+        {
+            lua_getfield(L, ptIdx, k.c_str());
+            if (lua_isstring(L, -1))
+                stPropTypes[k] = lua_tostring(L, -1);
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1);
+
     for (const auto& propName : stPropget)
     {
         MemberInfo m;
         m.name = propName;
         m.kind = stPropsetReal.count(propName) ? MemberKind::StaticProperty : MemberKind::StaticReadOnlyProperty;
-        m.overloads.push_back(OverloadInfo{});
+        OverloadInfo ov;
+        auto it = stPropTypes.find(propName);
+        if (it != stPropTypes.end())
+            ov.returnType = it->second;
+        m.overloads.push_back(std::move(ov));
         cls.members.push_back(std::move(m));
     }
 
@@ -9356,6 +9449,21 @@ inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::
     if (lua_istable(L, -1))
         nsPropsetTableIdx = lua_absindex(L, -1);
     
+    std::map<std::string, std::string> nsPropTypes;
+    lua_rawgetp_x(L, nsIdx, getPropTypeKey());
+    if (lua_istable(L, -1))
+    {
+        int ptIdx = lua_absindex(L, -1);
+        for (const auto& k : nsPropget)
+        {
+            lua_getfield(L, ptIdx, k.c_str());
+            if (lua_isstring(L, -1))
+                nsPropTypes[k] = lua_tostring(L, -1);
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1); 
+
     for (const auto& propName : nsPropget)
     {
         MemberInfo m;
@@ -9374,7 +9482,11 @@ inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::
         }
 
         m.kind = isReadOnly ? MemberKind::ReadOnlyProperty : MemberKind::Property;
-        m.overloads.push_back(OverloadInfo{});
+        OverloadInfo ov;
+        auto it = nsPropTypes.find(propName);
+        if (it != nsPropTypes.end())
+            ov.returnType = it->second;
+        m.overloads.push_back(std::move(ov));
         info.freeMembers.push_back(std::move(m));
     }
 
@@ -9620,16 +9732,29 @@ class ConsoleVisitor : public InspectVisitor
         switch (m.kind)
         {
         case MemberKind::Property:
-            indent(); out_ << m.name << ": any;\n"; break;
+            indent();
+            out_ << m.name << ": any;\n";
+            break;
+
         case MemberKind::ReadOnlyProperty:
-            indent(); out_ << "readonly " << m.name << ": any;\n"; break;
+            indent();
+            out_ << "readonly " << m.name << ": any;\n";
+            break;
+
         case MemberKind::StaticProperty:
-            indent(); out_ << "static " << m.name << ": any;\n"; break;
+            indent();
+            out_ << "static " << m.name << ": any;\n";
+            break;
+        
         case MemberKind::StaticReadOnlyProperty:
-            indent(); out_ << "static readonly " << m.name << ": any;\n"; break;
+            indent();
+            out_ << "static readonly " << m.name << ": any;\n";
+            break;
+
         case MemberKind::Metamethod:
             
             break;
+
         case MemberKind::Constructor:
             for (const auto& ov : m.overloads)
             {
@@ -9637,10 +9762,11 @@ class ConsoleVisitor : public InspectVisitor
                 out_ << "constructor(" << paramStr(ov) << ");\n";
             }
             break;
+
         case MemberKind::Method:
         case MemberKind::StaticMethod:
         {
-            bool isStatic = (m.kind == MemberKind::StaticMethod);
+            const bool isStatic = (m.kind == MemberKind::StaticMethod);
             for (std::size_t i = 0; i < m.overloads.size(); ++i)
             {
                 indent();
@@ -9649,6 +9775,7 @@ class ConsoleVisitor : public InspectVisitor
             }
             break;
         }
+
         default:
             break;
         }
@@ -9680,7 +9807,7 @@ class LuaLSVisitor : public InspectVisitor
 
         for (const auto& ov : m.overloads)
         {
-            emitParams(ov.params);
+            emitParamsTo(out_, ov.params);
             if (!ov.returnType.empty() && ov.returnType != "void")
                 out_ << "---@return " << luaType(ov.returnType) << "\n";
         }
@@ -9703,95 +9830,101 @@ class LuaLSVisitor : public InspectVisitor
                 out_ << ", " << cls.baseClasses[i];
         }
         out_ << "\n";
-
+        methodBuf_.str({});
+        methodBuf_.clear();
     }
 
     void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
     {
-        out_ << "local " << curClass_ << " = {}\n\n";
+        out_ << "local " << curClass_ << " = {}\n";
+        const std::string methods = methodBuf_.str();
+        if (!methods.empty())
+            out_ << "\n" << methods;
+        else
+            out_ << "\n";
         curClass_.clear();
     }
 
     void visitMember(const ClassInspectInfo& cls, const MemberInfo& m) override
     {
+        auto propType = [&]() -> std::string {
+            if (!m.overloads.empty() && !m.overloads[0].returnType.empty())
+                return luaType(m.overloads[0].returnType);
+            return "any";
+        };
+
         switch (m.kind)
         {
         case MemberKind::Property:
-            out_ << "---@field " << m.name << " any\n";
+            out_ << "---@field " << m.name << " " << propType() << "\n";
             break;
+
         case MemberKind::ReadOnlyProperty:
-            out_ << "---@field " << m.name << " any # readonly\n";
+            out_ << "---@field " << m.name << " " << propType() << " # readonly\n";
             break;
+
         case MemberKind::StaticProperty:
-            out_ << "---@field " << m.name << " any\n";
+            out_ << "---@field " << m.name << " " << propType() << "\n";
             break;
+
         case MemberKind::StaticReadOnlyProperty:
-            out_ << "---@field " << m.name << " any # readonly\n";
+            out_ << "---@field " << m.name << " " << propType() << " # readonly\n";
             break;
+
         case MemberKind::Constructor:
         {
-            out_ << "\n";
-            for (std::size_t i = 0; i < m.overloads.size(); ++i)
-            {
-                const auto& ov = m.overloads[i];
-                if (i == 0)
-                {
-                    emitParams(ov.params);
-                    out_ << "---@return " << cls.name << "\n";
-                    out_ << "function " << cls.name << ".new(" << paramNames(ov.params) << ") end\n";
-                }
-                else
-                {
-                    out_ << "---@overload fun(" << overloadParams(ov.params) << "): " << cls.name << "\n";
-                }
-            }
+            
+            std::string qname = qualifiedName(cls.name);
+            for (const auto& ov : m.overloads)
+                out_ << "---@overload fun(" << overloadParams(ov.params) << "): " << qname << "\n";
             break;
         }
+
         case MemberKind::Method:
         {
-            out_ << "\n";
+            std::string qname = qualifiedName(cls.name);
             for (std::size_t i = 0; i < m.overloads.size(); ++i)
             {
                 const auto& ov = m.overloads[i];
                 if (i == 0)
                 {
-                    emitParams(ov.params, 
-true);
+                    emitParamsTo(methodBuf_, ov.params, 
+true, qname);
                     if (!ov.returnType.empty() && ov.returnType != "void")
-                        out_ << "---@return " << luaType(ov.returnType) << "\n";
-                    out_ << "function " << cls.name << ":" << m.name
-                         << "(" << paramNames(ov.params) << ") end\n";
+                        methodBuf_ << "---@return " << luaType(ov.returnType) << "\n";
+                    methodBuf_ << "function " << qname << ":" << m.name << "(" << paramNames(ov.params) << ") end\n\n";
                 }
                 else
                 {
-                    out_ << "---@overload fun(self: " << cls.name << ", " << overloadParams(ov.params) << ")"
-                         << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
+                    methodBuf_ << "---@overload fun(self: " << qname << ", " << overloadParams(ov.params) << ")"
+                               << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
                 }
             }
             break;
         }
+
         case MemberKind::StaticMethod:
         {
-            out_ << "\n";
+            std::string qname = qualifiedName(cls.name);
             for (std::size_t i = 0; i < m.overloads.size(); ++i)
             {
                 const auto& ov = m.overloads[i];
                 if (i == 0)
                 {
-                    emitParams(ov.params);
+                    emitParamsTo(methodBuf_, ov.params);
                     if (!ov.returnType.empty() && ov.returnType != "void")
-                        out_ << "---@return " << luaType(ov.returnType) << "\n";
-                    out_ << "function " << cls.name << "." << m.name
-                         << "(" << paramNames(ov.params) << ") end\n";
+                        methodBuf_ << "---@return " << luaType(ov.returnType) << "\n";
+                    methodBuf_ << "function " << qname << "." << m.name << "(" << paramNames(ov.params) << ") end\n\n";
                 }
                 else
                 {
-                    out_ << "---@overload fun(" << overloadParams(ov.params) << ")"
-                         << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
+                    methodBuf_ << "---@overload fun(" << overloadParams(ov.params) << ")"
+                               << (ov.returnType.empty() ? "" : (": " + luaType(ov.returnType))) << "\n";
                 }
             }
             break;
         }
+
         default:
             break;
         }
@@ -9802,15 +9935,20 @@ true);
     static std::string luaType(const std::string& cppType)
     {
         if (cppType == "void") return "nil";
+
         if (cppType == "bool") return "boolean";
+
         if (cppType == "int" || cppType == "long" || cppType == "short" ||
             cppType == "unsigned int" || cppType == "unsigned long" ||
             cppType == "unsigned short" || cppType == "int64_t" || cppType == "uint64_t" ||
             cppType == "int32_t" || cppType == "uint32_t" || cppType == "size_t")
             return "integer";
+
         if (cppType == "float" || cppType == "double") return "number";
+
         if (cppType == "std::string" || cppType == "const char *" || cppType == "const char*")
             return "string";
+
         return cppType.empty() ? "any" : cppType;
     }
 
@@ -9836,6 +9974,7 @@ true);
         for (std::size_t i = 0; i < params.size(); ++i)
         {
             if (i) s += ", ";
+
             const auto& p = params[i];
             std::string pname = p.hint.empty() ? ("p" + std::to_string(i + 1)) : p.hint;
             s += pname + ": " + luaType(p.typeName.empty() ? "any" : p.typeName);
@@ -9843,20 +9982,23 @@ true);
         return s;
     }
 
-    void emitParams(const std::vector<ParamInfo>& params, bool hasSelf = false) const
+    static void emitParamsTo(std::ostream& os, const std::vector<ParamInfo>& params,
+                             bool hasSelf = false, const std::string& selfType = {})
     {
         if (hasSelf)
-            out_ << "---@param self " << curClass_ << "\n";
+            os << "---@param self " << selfType << "\n";
+
         for (std::size_t i = 0; i < params.size(); ++i)
         {
             const auto& p = params[i];
             std::string pname = p.hint.empty() ? ("p" + std::to_string(i + 1)) : p.hint;
             std::string ptype = p.typeName.empty() ? "any" : luaType(p.typeName);
-            out_ << "---@param " << pname << " " << ptype << "\n";
+            os << "---@param " << pname << " " << ptype << "\n";
         }
     }
 
     std::ostream& out_;
+    std::ostringstream methodBuf_;
     std::string ns_;
     std::string curClass_;
 };
@@ -9871,14 +10013,16 @@ class LuaProxyVisitor : public InspectVisitor
 
     void beginNamespace(const NamespaceInspectInfo& ns) override
     {
-        if (ns.name != "_G")
-            out_ << "local " << ns.name << " = {}\n\n";
+        curNs_ = (ns.name == "_G") ? "" : ns.name;
+        if (!curNs_.empty())
+            out_ << "local " << curNs_ << " = {}\n\n";
     }
 
     void endNamespace(const NamespaceInspectInfo& ns) override
     {
         if (ns.name != "_G")
             out_ << "return " << ns.name << "\n";
+        curNs_.clear();
     }
 
     void visitFreeMember(const NamespaceInspectInfo& ns, const MemberInfo& m) override
@@ -9896,8 +10040,9 @@ class LuaProxyVisitor : public InspectVisitor
     void beginClass(const ClassInspectInfo& cls) override
     {
         curClass_ = cls.name;
-        out_ << cls.name << " = {}\n";
-        out_ << cls.name << ".__index = " << cls.name << "\n\n";
+        std::string qname = curNs_.empty() ? cls.name : (curNs_ + "." + cls.name);
+        out_ << qname << " = {}\n";
+        out_ << qname << ".__index = " << qname << "\n\n";
     }
 
     void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
@@ -9911,28 +10056,35 @@ class LuaProxyVisitor : public InspectVisitor
         if (m.overloads.empty())
             return;
 
+        std::string qname = curNs_.empty() ? curClass_ : (curNs_ + "." + curClass_);
+
         switch (m.kind)
         {
         case MemberKind::Constructor:
-            out_ << "function " << curClass_ << ".new("
-                 << paramNames(m.overloads[0].params) << ")\n"
-                 << "    return setmetatable({}, " << curClass_ << ")\n"
-                 << "end\n\n";
+            
+            out_ << "setmetatable(" << qname << ", {__call = function(t";
+            if (!m.overloads[0].params.empty())
+                out_ << ", " << paramNames(m.overloads[0].params);
+            out_ << ")\n    return setmetatable({}, t)\nend})\n\n";
             break;
+
         case MemberKind::Method:
-            out_ << "function " << curClass_ << ":" << m.name
-                 << "(" << paramNames(m.overloads[0].params) << ") end\n";
+            out_ << "function " << qname << ":" << m.name
+                 << "(" << paramNames(m.overloads[0].params) << ") end\n\n";
             break;
+
         case MemberKind::StaticMethod:
-            out_ << "function " << curClass_ << "." << m.name
-                 << "(" << paramNames(m.overloads[0].params) << ") end\n";
+            out_ << "function " << qname << "." << m.name
+                 << "(" << paramNames(m.overloads[0].params) << ") end\n\n";
             break;
+
         case MemberKind::Property:
         case MemberKind::ReadOnlyProperty:
         case MemberKind::StaticProperty:
         case MemberKind::StaticReadOnlyProperty:
             
             break;
+
         default:
             break;
         }
@@ -9951,115 +10103,10 @@ class LuaProxyVisitor : public InspectVisitor
     }
 
     std::ostream& out_;
+    std::string curNs_;
     std::string curClass_;
 };
 
-class JsonVisitor : public InspectVisitor
-{
-public:
-    explicit JsonVisitor(std::ostream& out)
-        : out_(out)
-    {
-    }
-
-    void beginNamespace(const NamespaceInspectInfo& ns) override
-    {
-        if (depth_ == 0) out_ << "{\n";
-        indent(); out_ << "\"name\": \"" << escape(ns.name) << "\",\n";
-        indent(); out_ << "\"freeMembers\": [],\n";
-        indent(); out_ << "\"classes\": [\n";
-        ++depth_;
-        firstClass_ = true;
-    }
-
-    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
-    {
-        --depth_;
-        out_ << "\n";
-        indent(); out_ << "]\n";
-        if (depth_ == 0) out_ << "}\n";
-    }
-
-    void beginClass(const ClassInspectInfo& cls) override
-    {
-        if (!firstClass_) out_ << ",\n";
-        firstClass_ = false;
-        indent(); out_ << "{\n";
-        ++depth_;
-        indent(); out_ << "\"name\": \"" << escape(cls.name) << "\",\n";
-        indent(); out_ << "\"bases\": [";
-        for (std::size_t i = 0; i < cls.baseClasses.size(); ++i)
-        {
-            if (i) out_ << ", ";
-            out_ << "\"" << escape(cls.baseClasses[i]) << "\"";
-        }
-        out_ << "],\n";
-        indent(); out_ << "\"members\": [\n";
-        ++depth_;
-        firstMember_ = true;
-    }
-
-    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
-    {
-        --depth_;
-        out_ << "\n";
-        indent(); out_ << "]\n";
-        --depth_;
-        indent(); out_ << "}";
-    }
-
-    void visitMember([[maybe_unused]] const ClassInspectInfo& cls, const MemberInfo& m) override
-    {
-        if (!firstMember_) out_ << ",\n";
-        firstMember_ = false;
-        indent();
-        out_ << "{ \"name\": \"" << escape(m.name) << "\""
-             << ", \"kind\": \"" << kindStr(m.kind) << "\""
-             << ", \"overloads\": " << m.overloads.size()
-             << " }";
-    }
-
-private:
-    void indent() const
-    {
-        for (int i = 0; i < depth_; ++i)
-            out_ << "  ";
-    }
-
-    static std::string escape(const std::string& s)
-    {
-        std::string out;
-        for (char c : s)
-        {
-            if (c == '"') out += "\\\"";
-            else if (c == '\\') out += "\\\\";
-            else out += c;
-        }
-        return out;
-    }
-
-    static const char* kindStr(MemberKind k)
-    {
-        switch (k)
-        {
-        case MemberKind::Method: return "method";
-        case MemberKind::StaticMethod: return "static_method";
-        case MemberKind::Property: return "property";
-        case MemberKind::ReadOnlyProperty: return "readonly_property";
-        case MemberKind::StaticProperty: return "static_property";
-        case MemberKind::StaticReadOnlyProperty: return "static_readonly_property";
-        case MemberKind::Constructor: return "constructor";
-        case MemberKind::Metamethod: return "metamethod";
-        default: return "unknown";
-        }
-    }
-
-    std::ostream& out_;
-    int depth_ = 0;
-    bool firstClass_ = true;
-    bool firstMember_ = true;
-};
-
 class LuaTableVisitor : public InspectVisitor
 {
 public:
@@ -12951,6 +12998,9 @@ class Namespace : public detail::Registrar
             detail::push_property_readonly(L, name); 
             detail::add_property_setter(L, name, -2); 
 
+            using RetType = detail::getter_return_t<Getter>;
+            detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -1); 
+
             return *this;
         }
 
@@ -12966,6 +13016,9 @@ class Namespace : public detail::Registrar
             detail::push_property_setter(L, std::move(set), name); 
             detail::add_property_setter(L, name, -2); 
 
+            using RetType = detail::getter_return_t<Getter>;
+            detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -1); 
+
             return *this;
         }
 
@@ -13141,6 +13194,9 @@ class Namespace : public detail::Registrar
             detail::push_property_readonly(L, name); 
             detail::add_property_setter(L, name, -3); 
 
+            using RetType = detail::getter_return_t<Getter>;
+            detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -2); 
+
             return *this;
         }
 
@@ -13158,6 +13214,9 @@ class Namespace : public detail::Registrar
             detail::push_class_property_setter<T>(L, std::move(setter), name); 
             detail::add_property_setter(L, name, -3); 
 
+            using RetType = detail::getter_return_t<Getter>;
+            detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -2); 
+
             return *this;
         }
 
@@ -14052,6 +14111,9 @@ class Namespace : public detail::Registrar
         detail::push_property_readonly(L, name); 
         detail::add_property_setter(L, name, -2); 
 
+        using RetType = detail::getter_return_t<Getter>;
+        detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -1); 
+
         return *this;
     }
 
@@ -14074,6 +14136,9 @@ class Namespace : public detail::Registrar
         detail::push_property_setter(L, std::move(setter), name); 
         detail::add_property_setter(L, name, -2); 
 
+        using RetType = detail::getter_return_t<Getter>;
+        detail::add_property_type(L, name, std::string(detail::typeName<RetType>()).c_str(), -1); 
+
         return *this;
     }
 

From e03527920ec85b1a60326a5eb98011f12ff15593 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 7 Apr 2026 23:11:44 +0000
Subject: [PATCH 13/14] fix: LuaTableVisitor nested namespace handling with
 state stack

Replace flat freeMemberIdx_/classIdx_/subNsIdx_ member variables with a
std::vector<NsState> stack in LuaTableVisitor, and implement endNamespace()
to properly insert each sub-namespace table into the parent's subNamespaces
array and pop it from the Lua stack.

This fixes both the incorrect result structure and the Lua stack leak that
occurred when inspecting namespaces with sub-namespaces.

Also adds LuaTableVisitorHandlesNestedNamespaces test that verifies the
correct output structure and confirms the Lua stack is balanced after use.

Apply same fix to Distribution/LuaBridge/LuaBridge.h amalgam.

Agent-Logs-Url: https://github.com/kunitoki/LuaBridge3/sessions/e82019ab-faa5-48bb-8798-f4cdadde82f2

Co-authored-by: kunitoki <707032+kunitoki@users.noreply.github.com>
---
 Distribution/LuaBridge/LuaBridge.h | 33 +++++++++++-----
 Source/LuaBridge/Inspect.h         | 33 +++++++++++-----
 Tests/Source/InspectTests.cpp      | 60 ++++++++++++++++++++++++++++++
 3 files changed, 108 insertions(+), 18 deletions(-)

diff --git a/Distribution/LuaBridge/LuaBridge.h b/Distribution/LuaBridge/LuaBridge.h
index 7761c840..7b789144 100644
--- a/Distribution/LuaBridge/LuaBridge.h
+++ b/Distribution/LuaBridge/LuaBridge.h
@@ -10123,27 +10123,37 @@ class LuaTableVisitor : public InspectVisitor
 
         lua_newtable(L_);
         lua_setfield(L_, -2, "freeMembers");
-        freeMemberIdx_ = 1;
 
         lua_newtable(L_);
         lua_setfield(L_, -2, "classes");
-        classIdx_ = 1;
 
         lua_newtable(L_);
         lua_setfield(L_, -2, "subNamespaces");
-        subNsIdx_ = 1;
+
+        nsStack_.push_back({});
     }
 
     void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
     {
-        
+        nsStack_.pop_back();
+
+        if (!nsStack_.empty())
+        {
+            // Sub-namespace table is on top; store it in the parent's "subNamespaces" array.
+            // Stack: [..., parent_ns_table, sub_ns_table]
+            lua_getfield(L_, -2, "subNamespaces");         // [..., parent_ns_table, sub_ns_table, subNS_array]
+            lua_pushvalue(L_, -2);                         // [..., parent_ns_table, sub_ns_table, subNS_array, sub_ns_table]
+            lua_rawseti(L_, -2, nsStack_.back().subNsIdx++); // store sub_ns_table into subNS_array
+            lua_pop(L_, 2);                                // pop subNS_array + sub_ns_table
+            // Stack: [..., parent_ns_table]
+        }
     }
 
     void visitFreeMember([[maybe_unused]] const NamespaceInspectInfo& ns, const MemberInfo& m) override
     {
         lua_getfield(L_, -1, "freeMembers");
         pushMemberInfo(m);
-        lua_rawseti(L_, -2, freeMemberIdx_++);
+        lua_rawseti(L_, -2, nsStack_.back().freeMemberIdx++);
         lua_pop(L_, 1);
     }
 
@@ -10171,7 +10181,7 @@ class LuaTableVisitor : public InspectVisitor
         
         lua_getfield(L_, -2, "classes");
         lua_pushvalue(L_, -2);
-        lua_rawseti(L_, -2, classIdx_++);
+        lua_rawseti(L_, -2, nsStack_.back().classIdx++);
         lua_pop(L_, 2); 
     }
 
@@ -10184,6 +10194,13 @@ class LuaTableVisitor : public InspectVisitor
     }
 
 private:
+    struct NsState
+    {
+        int freeMemberIdx = 1;
+        int classIdx = 1;
+        int subNsIdx = 1;
+    };
+
     void pushMemberInfo(const MemberInfo& m)
     {
         lua_newtable(L_);
@@ -10235,9 +10252,7 @@ class LuaTableVisitor : public InspectVisitor
     }
 
     lua_State* L_;
-    int freeMemberIdx_ = 1;
-    int classIdx_ = 1;
-    int subNsIdx_ = 1;
+    std::vector<NsState> nsStack_;
     int memberIdx_ = 1;
 };
 
diff --git a/Source/LuaBridge/Inspect.h b/Source/LuaBridge/Inspect.h
index 29b4d5b5..75bf145f 100644
--- a/Source/LuaBridge/Inspect.h
+++ b/Source/LuaBridge/Inspect.h
@@ -1271,27 +1271,37 @@ class LuaTableVisitor : public InspectVisitor
 
         lua_newtable(L_);
         lua_setfield(L_, -2, "freeMembers");
-        freeMemberIdx_ = 1;
 
         lua_newtable(L_);
         lua_setfield(L_, -2, "classes");
-        classIdx_ = 1;
 
         lua_newtable(L_);
         lua_setfield(L_, -2, "subNamespaces");
-        subNsIdx_ = 1;
+
+        nsStack_.push_back({});
     }
 
     void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
     {
-        // namespace table stays on stack as the result
+        nsStack_.pop_back();
+
+        if (!nsStack_.empty())
+        {
+            // Sub-namespace table is on top; store it in the parent's "subNamespaces" array.
+            // Stack: [..., parent_ns_table, sub_ns_table]
+            lua_getfield(L_, -2, "subNamespaces");         // [..., parent_ns_table, sub_ns_table, subNS_array]
+            lua_pushvalue(L_, -2);                         // [..., parent_ns_table, sub_ns_table, subNS_array, sub_ns_table]
+            lua_rawseti(L_, -2, nsStack_.back().subNsIdx++); // store sub_ns_table into subNS_array
+            lua_pop(L_, 2);                                // pop subNS_array + sub_ns_table
+            // Stack: [..., parent_ns_table]
+        }
     }
 
     void visitFreeMember([[maybe_unused]] const NamespaceInspectInfo& ns, const MemberInfo& m) override
     {
         lua_getfield(L_, -1, "freeMembers");
         pushMemberInfo(m);
-        lua_rawseti(L_, -2, freeMemberIdx_++);
+        lua_rawseti(L_, -2, nsStack_.back().freeMemberIdx++);
         lua_pop(L_, 1);
     }
 
@@ -1319,7 +1329,7 @@ class LuaTableVisitor : public InspectVisitor
         // class table is on top; store it in the namespace's "classes" array
         lua_getfield(L_, -2, "classes");
         lua_pushvalue(L_, -2);
-        lua_rawseti(L_, -2, classIdx_++);
+        lua_rawseti(L_, -2, nsStack_.back().classIdx++);
         lua_pop(L_, 2); // pop classes table + class table
     }
 
@@ -1332,6 +1342,13 @@ class LuaTableVisitor : public InspectVisitor
     }
 
 private:
+    struct NsState
+    {
+        int freeMemberIdx = 1;
+        int classIdx = 1;
+        int subNsIdx = 1;
+    };
+
     void pushMemberInfo(const MemberInfo& m)
     {
         lua_newtable(L_);
@@ -1384,9 +1401,7 @@ class LuaTableVisitor : public InspectVisitor
     }
 
     lua_State* L_;
-    int freeMemberIdx_ = 1;
-    int classIdx_ = 1;
-    int subNsIdx_ = 1;
+    std::vector<NsState> nsStack_;
     int memberIdx_ = 1;
 };
 
diff --git a/Tests/Source/InspectTests.cpp b/Tests/Source/InspectTests.cpp
index 268f0a9f..c3fc9049 100644
--- a/Tests/Source/InspectTests.cpp
+++ b/Tests/Source/InspectTests.cpp
@@ -343,6 +343,66 @@ TEST_F(InspectTests, LuaTableVisitorProducesTable)
     EXPECT_EQ(topBefore, lua_gettop(L));
 }
 
+TEST_F(InspectTests, LuaTableVisitorHandlesNestedNamespaces)
+{
+    struct OuterCls { void outerMethod() {} };
+    struct InnerCls { void innerMethod() {} };
+
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("Outer")
+            .beginClass<OuterCls>("OuterCls")
+                .addFunction("outerMethod", &OuterCls::outerMethod)
+            .endClass()
+            .beginNamespace("Inner")
+                .beginClass<InnerCls>("InnerCls")
+                    .addFunction("innerMethod", &InnerCls::innerMethod)
+                .endClass()
+            .endNamespace()
+        .endNamespace();
+
+    int topBefore = lua_gettop(L);
+    luabridge::inspectToLua(L, "Outer");
+
+    // Stack must grow by exactly 1
+    ASSERT_EQ(topBefore + 1, lua_gettop(L));
+    ASSERT_TRUE(lua_istable(L, -1));
+
+    // Outer namespace name
+    lua_getfield(L, -1, "name");
+    EXPECT_STREQ("Outer", lua_tostring(L, -1));
+    lua_pop(L, 1);
+
+    // Outer classes array contains OuterCls
+    lua_getfield(L, -1, "classes");
+    EXPECT_TRUE(lua_istable(L, -1));
+    EXPECT_EQ(1, luabridge::get_length(L, -1));
+    lua_pop(L, 1);
+
+    // subNamespaces array contains the Inner namespace
+    lua_getfield(L, -1, "subNamespaces");
+    EXPECT_TRUE(lua_istable(L, -1));
+    EXPECT_EQ(1, luabridge::get_length(L, -1));
+
+    // Inspect the Inner sub-namespace table
+    lua_rawgeti(L, -1, 1);
+    ASSERT_TRUE(lua_istable(L, -1));
+
+    lua_getfield(L, -1, "name");
+    EXPECT_STREQ("Inner", lua_tostring(L, -1));
+    lua_pop(L, 1);
+
+    lua_getfield(L, -1, "classes");
+    EXPECT_TRUE(lua_istable(L, -1));
+    EXPECT_EQ(1, luabridge::get_length(L, -1));
+    lua_pop(L, 1);
+
+    lua_pop(L, 1); // pop Inner table
+    lua_pop(L, 1); // pop subNamespaces table
+
+    lua_pop(L, 1); // pop result table
+    EXPECT_EQ(topBefore, lua_gettop(L));
+}
+
 TEST_F(InspectTests, LuaLSVisitorProducesAnnotations)
 {
     struct Cls { int getValue() const { return 0; } };

From c0c14d7be044c2ece373d6ca93f5444b5206829e Mon Sep 17 00:00:00 2001
From: kunitoki <kunitoki@gmail.com>
Date: Wed, 8 Apr 2026 01:59:22 +0200
Subject: [PATCH 14/14] Updated headers and manual

---
 Distribution/LuaBridge/LuaBridge.h | 178 +++----------------------
 Manual.md                          |  23 +++-
 Source/LuaBridge/Inspect.h         | 203 +++--------------------------
 Tests/Source/InspectTests.cpp      |  89 -------------
 4 files changed, 53 insertions(+), 440 deletions(-)

diff --git a/Distribution/LuaBridge/LuaBridge.h b/Distribution/LuaBridge/LuaBridge.h
index 7b789144..bcd226c7 100644
--- a/Distribution/LuaBridge/LuaBridge.h
+++ b/Distribution/LuaBridge/LuaBridge.h
@@ -9017,10 +9017,6 @@ struct container_forwarder
 
 // Begin File: Source/LuaBridge/Inspect.h
 
-#if ! LUABRIDGE_ENABLE_REFLECT
-#error "This header is only for use when LUABRIDGE_ENABLE_REFLECT is active."
-#endif
-
 namespace luabridge {
 
 struct NamespaceInspectInfo;
@@ -9551,6 +9547,7 @@ inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::
 template <class T>
 [[nodiscard]] ClassInspectInfo inspect(lua_State* L)
 {
+#if LUABRIDGE_ENABLE_REFLECT
     
     lua_rawgetp_x(L, LUA_REGISTRYINDEX, detail::getClassRegistryKey<T>());
     if (!lua_istable(L, -1))
@@ -9580,10 +9577,15 @@ template <class T>
     
     lua_pop(L, 1); 
     return result;
+#else
+    unused(L);
+    return {};
+#endif
 }
 
 [[nodiscard]] inline NamespaceInspectInfo inspectNamespace(lua_State* L, const char* namespaceName = nullptr)
 {
+#if LUABRIDGE_ENABLE_REFLECT
     if (namespaceName == nullptr || namespaceName[0] == '\0')
     {
         lua_getglobal(L, "_G");
@@ -9635,12 +9637,20 @@ template <class T>
     auto result = detail::inspectNamespaceTable(L, -1, label);
     lua_pop(L, 1);
     return result;
+#else
+    unused(L, namespaceName);
+    return {};
+#endif
 }
 
 inline void inspectAccept(lua_State* L, const char* namespaceName, InspectVisitor& visitor)
 {
+#if LUABRIDGE_ENABLE_REFLECT
     auto ns = inspectNamespace(L, namespaceName);
     accept(ns, visitor);
+#else
+    unused(L, namespaceName, visitor);
+#endif
 }
 
 class ConsoleVisitor : public InspectVisitor
@@ -10107,167 +10117,15 @@ class LuaProxyVisitor : public InspectVisitor
     std::string curClass_;
 };
 
-class LuaTableVisitor : public InspectVisitor
-{
-public:
-    explicit LuaTableVisitor(lua_State* L)
-        : L_(L)
-    {
-    }
-
-    void beginNamespace(const NamespaceInspectInfo& ns) override
-    {
-        lua_newtable(L_); 
-        lua_pushstring(L_, ns.name.c_str());
-        lua_setfield(L_, -2, "name");
-
-        lua_newtable(L_);
-        lua_setfield(L_, -2, "freeMembers");
-
-        lua_newtable(L_);
-        lua_setfield(L_, -2, "classes");
-
-        lua_newtable(L_);
-        lua_setfield(L_, -2, "subNamespaces");
-
-        nsStack_.push_back({});
-    }
-
-    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
-    {
-        nsStack_.pop_back();
-
-        if (!nsStack_.empty())
-        {
-            // Sub-namespace table is on top; store it in the parent's "subNamespaces" array.
-            // Stack: [..., parent_ns_table, sub_ns_table]
-            lua_getfield(L_, -2, "subNamespaces");         // [..., parent_ns_table, sub_ns_table, subNS_array]
-            lua_pushvalue(L_, -2);                         // [..., parent_ns_table, sub_ns_table, subNS_array, sub_ns_table]
-            lua_rawseti(L_, -2, nsStack_.back().subNsIdx++); // store sub_ns_table into subNS_array
-            lua_pop(L_, 2);                                // pop subNS_array + sub_ns_table
-            // Stack: [..., parent_ns_table]
-        }
-    }
-
-    void visitFreeMember([[maybe_unused]] const NamespaceInspectInfo& ns, const MemberInfo& m) override
-    {
-        lua_getfield(L_, -1, "freeMembers");
-        pushMemberInfo(m);
-        lua_rawseti(L_, -2, nsStack_.back().freeMemberIdx++);
-        lua_pop(L_, 1);
-    }
-
-    void beginClass(const ClassInspectInfo& cls) override
-    {
-        lua_newtable(L_);
-        lua_pushstring(L_, cls.name.c_str());
-        lua_setfield(L_, -2, "name");
-
-        lua_newtable(L_);
-        for (std::size_t i = 0; i < cls.baseClasses.size(); ++i)
-        {
-            lua_pushstring(L_, cls.baseClasses[i].c_str());
-            lua_rawseti(L_, -2, static_cast<int>(i + 1));
-        }
-        lua_setfield(L_, -2, "bases");
-
-        lua_newtable(L_);
-        lua_setfield(L_, -2, "members");
-        memberIdx_ = 1;
-    }
-
-    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
-    {
-        
-        lua_getfield(L_, -2, "classes");
-        lua_pushvalue(L_, -2);
-        lua_rawseti(L_, -2, nsStack_.back().classIdx++);
-        lua_pop(L_, 2); 
-    }
-
-    void visitMember([[maybe_unused]] const ClassInspectInfo& cls, const MemberInfo& m) override
-    {
-        lua_getfield(L_, -1, "members");
-        pushMemberInfo(m);
-        lua_rawseti(L_, -2, memberIdx_++);
-        lua_pop(L_, 1);
-    }
-
-private:
-    struct NsState
-    {
-        int freeMemberIdx = 1;
-        int classIdx = 1;
-        int subNsIdx = 1;
-    };
-
-    void pushMemberInfo(const MemberInfo& m)
-    {
-        lua_newtable(L_);
-        lua_pushstring(L_, m.name.c_str());
-        lua_setfield(L_, -2, "name");
-        lua_pushstring(L_, kindStr(m.kind));
-        lua_setfield(L_, -2, "kind");
-        lua_pushinteger(L_, static_cast<lua_Integer>(m.overloads.size()));
-        lua_setfield(L_, -2, "overloads");
-
-        lua_newtable(L_);
-        for (std::size_t i = 0; i < m.overloads.size(); ++i)
-        {
-            const auto& ov = m.overloads[i];
-            lua_newtable(L_);
-            lua_pushstring(L_, ov.returnType.c_str());
-            lua_setfield(L_, -2, "returnType");
-
-            lua_newtable(L_);
-            for (std::size_t j = 0; j < ov.params.size(); ++j)
-            {
-                lua_newtable(L_);
-                lua_pushstring(L_, ov.params[j].typeName.c_str());
-                lua_setfield(L_, -2, "type");
-                lua_pushstring(L_, ov.params[j].hint.c_str());
-                lua_setfield(L_, -2, "hint");
-                lua_rawseti(L_, -2, static_cast<int>(j + 1));
-            }
-            lua_setfield(L_, -2, "params");
-            lua_rawseti(L_, -2, static_cast<int>(i + 1));
-        }
-        lua_setfield(L_, -2, "overloadDetails");
-    }
-
-    static const char* kindStr(MemberKind k)
-    {
-        switch (k)
-        {
-        case MemberKind::Method: return "method";
-        case MemberKind::StaticMethod: return "static_method";
-        case MemberKind::Property: return "property";
-        case MemberKind::ReadOnlyProperty: return "readonly_property";
-        case MemberKind::StaticProperty: return "static_property";
-        case MemberKind::StaticReadOnlyProperty: return "static_readonly_property";
-        case MemberKind::Constructor: return "constructor";
-        case MemberKind::Metamethod: return "metamethod";
-        default: return "unknown";
-        }
-    }
-
-    lua_State* L_;
-    std::vector<NsState> nsStack_;
-    int memberIdx_ = 1;
-};
-
 inline void inspectPrint(lua_State* L, const char* namespaceName = nullptr, std::ostream& stream = std::cerr)
 {
+#if LUABRIDGE_ENABLE_REFLECT
     auto ns = inspectNamespace(L, namespaceName);
     ConsoleVisitor v(stream);
     accept(ns, v);
-}
-
-inline void inspectToLua(lua_State* L, const char* namespaceName = nullptr)
-{
-    auto ns = inspectNamespace(L, namespaceName);
-    LuaTableVisitor v(L);
-    accept(ns, v);
+#else
+    unused(L, namespaceName, stream);
+#endif
 }
 
 } 
diff --git a/Manual.md b/Manual.md
index 8b0e7fd4..ec640145 100644
--- a/Manual.md
+++ b/Manual.md
@@ -676,7 +676,7 @@ When `LUABRIDGE_ENABLE_REFLECT` is defined (see [7.6](#76---luabridge-enable-ref
 ```cpp
 #define LUABRIDGE_ENABLE_REFLECT
 #include <LuaBridge/LuaBridge.h>
-#include <LuaBridge/Inspect.h>
+#include <LuaBridge/Inspect.h>  // source headers only; omit when using the amalgama
 
 struct Enemy
 {
@@ -2109,12 +2109,19 @@ luabridge::getGlobalNamespace (L)
 
 LuaBridge3 can introspect its own registration tables at runtime, making it straightforward to generate documentation, build IDE auto-complete databases, produce TypeScript type declarations, or validate that a binding matches an expected schema.
 
-The inspection API lives in the **optional** header `<LuaBridge/Inspect.h>`, which must be included separately and **requires** `LUABRIDGE_ENABLE_REFLECT` to be defined (see [7.6](#76---luabridge-enable-reflect)).
+The inspection API lives in the **optional** header `<LuaBridge/Inspect.h>`. When using the individual source headers, it must be included separately after `<LuaBridge/LuaBridge.h>`. When using the single-file amalgama (`Distribution/LuaBridge/LuaBridge.h`), `Inspect.h` is already embedded and no separate include is needed.
+
+Define `LUABRIDGE_ENABLE_REFLECT` before any LuaBridge header to enable C++ type-name capture (see [7.6](#76---luabridge-enable-reflect)). The inspection API works without it — type names will simply be empty strings.
 
 ```cpp
-#define LUABRIDGE_ENABLE_REFLECT
+// Source headers: include Inspect.h separately (optional)
+#define LUABRIDGE_ENABLE_REFLECT   // optional: enables type-name capture
 #include <LuaBridge/LuaBridge.h>
 #include <LuaBridge/Inspect.h>
+
+// Amalgama: Inspect.h is already embedded — no separate include needed
+#define LUABRIDGE_ENABLE_REFLECT   // optional: enables type-name capture
+#include <LuaBridge/LuaBridge.h>
 ```
 
 6.1 - inspect\<T\> and inspectNamespace
@@ -2357,17 +2364,21 @@ When defined, LuaBridge captures the C++ type names of function parameters and r
 Enable reflection by defining the macro **before** including any LuaBridge header:
 
 ```cpp
+// Source headers
 #define LUABRIDGE_ENABLE_REFLECT
 #include <LuaBridge/LuaBridge.h>
 #include <LuaBridge/Inspect.h>  // optional: only needed when using the inspection API
+
+// Amalgama (Inspect.h is already embedded — no separate include needed)
+#define LUABRIDGE_ENABLE_REFLECT
+#include <LuaBridge/LuaBridge.h>
 ```
 
-> **Note:** `Inspect.h` unconditionally requires `LUABRIDGE_ENABLE_REFLECT` and will emit a `#error` if the macro is not defined. You may use `withHints` (see [2.5.2](#252---parameter-name-hints)) without including `Inspect.h`.
+> **Note:** `Inspect.h` does **not** require `LUABRIDGE_ENABLE_REFLECT` — it can always be included. Without the macro the inspection API still works; it just reports empty strings for type names. You may also use `withHints` (see [2.5.2](#252---parameter-name-hints)) without including `Inspect.h`.
 
 When `LUABRIDGE_ENABLE_REFLECT` is not defined:
 * `withHints` parameter name hints are ignored and are not available through inspection.
 * `OverloadInfo::returnType` and `ParamInfo::typeName` are empty strings.
-* The `Inspect.h` header cannot be included.
 
 Appendix - API Reference
 ========================
@@ -2809,7 +2820,7 @@ int lua_resume_x(lua_State* L, lua_State* from, int nargs, int* nresults = nullp
 bool lua_isyieldable_x(lua_State* L);
 ```
 
-Registration Inspection (requires `LUABRIDGE_ENABLE_REFLECT`, `<LuaBridge/Inspect.h>`)
+Registration Inspection (`<LuaBridge/Inspect.h>`, enhanced by `LUABRIDGE_ENABLE_REFLECT`)
 ---------------------------------------------------------------------------------------
 
 ```cpp
diff --git a/Source/LuaBridge/Inspect.h b/Source/LuaBridge/Inspect.h
index 75bf145f..acf5013f 100644
--- a/Source/LuaBridge/Inspect.h
+++ b/Source/LuaBridge/Inspect.h
@@ -4,10 +4,6 @@
 
 #pragma once
 
-#if ! LUABRIDGE_ENABLE_REFLECT
-#error "This header is only for use when LUABRIDGE_ENABLE_REFLECT is active."
-#endif
-
 #include "detail/CFunctions.h"
 #include "detail/ClassInfo.h"
 #include "detail/LuaHelpers.h"
@@ -627,6 +623,7 @@ inline NamespaceInspectInfo inspectNamespaceTable(lua_State* L, int nsIdx, std::
 template <class T>
 [[nodiscard]] ClassInspectInfo inspect(lua_State* L)
 {
+#if LUABRIDGE_ENABLE_REFLECT
     // Load the class table (cl) directly from the Lua registry
     lua_rawgetp_x(L, LUA_REGISTRYINDEX, detail::getClassRegistryKey<T>());
     if (!lua_istable(L, -1))
@@ -664,6 +661,10 @@ template <class T>
     // Stack: ..., cl
     lua_pop(L, 1); // pop cl
     return result;
+#else
+    unused(L);
+    return {};
+#endif
 }
 
 //=================================================================================================
@@ -677,6 +678,7 @@ template <class T>
  */
 [[nodiscard]] inline NamespaceInspectInfo inspectNamespace(lua_State* L, const char* namespaceName = nullptr)
 {
+#if LUABRIDGE_ENABLE_REFLECT
     if (namespaceName == nullptr || namespaceName[0] == '\0')
     {
         lua_getglobal(L, "_G");
@@ -729,6 +731,10 @@ template <class T>
     auto result = detail::inspectNamespaceTable(L, -1, label);
     lua_pop(L, 1);
     return result;
+#else
+    unused(L, namespaceName);
+    return {};
+#endif
 }
 
 //=================================================================================================
@@ -737,8 +743,12 @@ template <class T>
  */
 inline void inspectAccept(lua_State* L, const char* namespaceName, InspectVisitor& visitor)
 {
+#if LUABRIDGE_ENABLE_REFLECT
     auto ns = inspectNamespace(L, namespaceName);
     accept(ns, visitor);
+#else
+    unused(L, namespaceName, visitor);
+#endif
 }
 
 //=================================================================================================
@@ -1238,173 +1248,6 @@ class LuaProxyVisitor : public InspectVisitor
     std::string curClass_;
 };
 
-//=================================================================================================
-/**
- * @brief Visitor that builds a structured Lua table on the Lua stack.
- *
- * After calling accept() with this visitor, the stack top is a table with structure:
- * @code
- * {
- *   name = "MyNS",
- *   freeMembers = { {name=…, kind=…, overloads=…}, … },
- *   classes = {
- *     { name=…, bases={…}, members={ {name=…, kind=…, overloads=N}, … } },
- *     …
- *   },
- *   subNamespaces = { … }
- * }
- * @endcode
- */
-class LuaTableVisitor : public InspectVisitor
-{
-public:
-    explicit LuaTableVisitor(lua_State* L)
-        : L_(L)
-    {
-    }
-
-    void beginNamespace(const NamespaceInspectInfo& ns) override
-    {
-        lua_newtable(L_); // the namespace table
-        lua_pushstring(L_, ns.name.c_str());
-        lua_setfield(L_, -2, "name");
-
-        lua_newtable(L_);
-        lua_setfield(L_, -2, "freeMembers");
-
-        lua_newtable(L_);
-        lua_setfield(L_, -2, "classes");
-
-        lua_newtable(L_);
-        lua_setfield(L_, -2, "subNamespaces");
-
-        nsStack_.push_back({});
-    }
-
-    void endNamespace([[maybe_unused]] const NamespaceInspectInfo& ns) override
-    {
-        nsStack_.pop_back();
-
-        if (!nsStack_.empty())
-        {
-            // Sub-namespace table is on top; store it in the parent's "subNamespaces" array.
-            // Stack: [..., parent_ns_table, sub_ns_table]
-            lua_getfield(L_, -2, "subNamespaces");         // [..., parent_ns_table, sub_ns_table, subNS_array]
-            lua_pushvalue(L_, -2);                         // [..., parent_ns_table, sub_ns_table, subNS_array, sub_ns_table]
-            lua_rawseti(L_, -2, nsStack_.back().subNsIdx++); // store sub_ns_table into subNS_array
-            lua_pop(L_, 2);                                // pop subNS_array + sub_ns_table
-            // Stack: [..., parent_ns_table]
-        }
-    }
-
-    void visitFreeMember([[maybe_unused]] const NamespaceInspectInfo& ns, const MemberInfo& m) override
-    {
-        lua_getfield(L_, -1, "freeMembers");
-        pushMemberInfo(m);
-        lua_rawseti(L_, -2, nsStack_.back().freeMemberIdx++);
-        lua_pop(L_, 1);
-    }
-
-    void beginClass(const ClassInspectInfo& cls) override
-    {
-        lua_newtable(L_);
-        lua_pushstring(L_, cls.name.c_str());
-        lua_setfield(L_, -2, "name");
-
-        lua_newtable(L_);
-        for (std::size_t i = 0; i < cls.baseClasses.size(); ++i)
-        {
-            lua_pushstring(L_, cls.baseClasses[i].c_str());
-            lua_rawseti(L_, -2, static_cast<int>(i + 1));
-        }
-        lua_setfield(L_, -2, "bases");
-
-        lua_newtable(L_);
-        lua_setfield(L_, -2, "members");
-        memberIdx_ = 1;
-    }
-
-    void endClass([[maybe_unused]] const ClassInspectInfo& cls) override
-    {
-        // class table is on top; store it in the namespace's "classes" array
-        lua_getfield(L_, -2, "classes");
-        lua_pushvalue(L_, -2);
-        lua_rawseti(L_, -2, nsStack_.back().classIdx++);
-        lua_pop(L_, 2); // pop classes table + class table
-    }
-
-    void visitMember([[maybe_unused]] const ClassInspectInfo& cls, const MemberInfo& m) override
-    {
-        lua_getfield(L_, -1, "members");
-        pushMemberInfo(m);
-        lua_rawseti(L_, -2, memberIdx_++);
-        lua_pop(L_, 1);
-    }
-
-private:
-    struct NsState
-    {
-        int freeMemberIdx = 1;
-        int classIdx = 1;
-        int subNsIdx = 1;
-    };
-
-    void pushMemberInfo(const MemberInfo& m)
-    {
-        lua_newtable(L_);
-        lua_pushstring(L_, m.name.c_str());
-        lua_setfield(L_, -2, "name");
-        lua_pushstring(L_, kindStr(m.kind));
-        lua_setfield(L_, -2, "kind");
-        lua_pushinteger(L_, static_cast<lua_Integer>(m.overloads.size()));
-        lua_setfield(L_, -2, "overloads");
-
-        // Emit overload details when type info is available
-        lua_newtable(L_);
-        for (std::size_t i = 0; i < m.overloads.size(); ++i)
-        {
-            const auto& ov = m.overloads[i];
-            lua_newtable(L_);
-            lua_pushstring(L_, ov.returnType.c_str());
-            lua_setfield(L_, -2, "returnType");
-
-            lua_newtable(L_);
-            for (std::size_t j = 0; j < ov.params.size(); ++j)
-            {
-                lua_newtable(L_);
-                lua_pushstring(L_, ov.params[j].typeName.c_str());
-                lua_setfield(L_, -2, "type");
-                lua_pushstring(L_, ov.params[j].hint.c_str());
-                lua_setfield(L_, -2, "hint");
-                lua_rawseti(L_, -2, static_cast<int>(j + 1));
-            }
-            lua_setfield(L_, -2, "params");
-            lua_rawseti(L_, -2, static_cast<int>(i + 1));
-        }
-        lua_setfield(L_, -2, "overloadDetails");
-    }
-
-    static const char* kindStr(MemberKind k)
-    {
-        switch (k)
-        {
-        case MemberKind::Method: return "method";
-        case MemberKind::StaticMethod: return "static_method";
-        case MemberKind::Property: return "property";
-        case MemberKind::ReadOnlyProperty: return "readonly_property";
-        case MemberKind::StaticProperty: return "static_property";
-        case MemberKind::StaticReadOnlyProperty: return "static_readonly_property";
-        case MemberKind::Constructor: return "constructor";
-        case MemberKind::Metamethod: return "metamethod";
-        default: return "unknown";
-        }
-    }
-
-    lua_State* L_;
-    std::vector<NsState> nsStack_;
-    int memberIdx_ = 1;
-};
-
 //=================================================================================================
 /**
  * @brief Print a TypeScript-style inspection of a namespace to an ostream.
@@ -1413,23 +1256,13 @@ class LuaTableVisitor : public InspectVisitor
  */
 inline void inspectPrint(lua_State* L, const char* namespaceName = nullptr, std::ostream& stream = std::cerr)
 {
+#if LUABRIDGE_ENABLE_REFLECT
     auto ns = inspectNamespace(L, namespaceName);
     ConsoleVisitor v(stream);
     accept(ns, v);
-}
-
-//=================================================================================================
-/**
- * @brief Push a structured Lua table describing a namespace onto the Lua stack.
- *
- * Convenience wrapper around LuaTableVisitor.
- * Pushes exactly 1 value (the result table).
- */
-inline void inspectToLua(lua_State* L, const char* namespaceName = nullptr)
-{
-    auto ns = inspectNamespace(L, namespaceName);
-    LuaTableVisitor v(L);
-    accept(ns, v);
+#else
+    unused(L, namespaceName, stream);
+#endif
 }
 
 } // namespace luabridge
diff --git a/Tests/Source/InspectTests.cpp b/Tests/Source/InspectTests.cpp
index c3fc9049..2dc469ef 100644
--- a/Tests/Source/InspectTests.cpp
+++ b/Tests/Source/InspectTests.cpp
@@ -314,95 +314,6 @@ TEST_F(InspectTests, ConsoleVisitorProducesOutput)
     EXPECT_NE(std::string::npos, ss.str().find("Cls"));
 }
 
-TEST_F(InspectTests, LuaTableVisitorProducesTable)
-{
-    struct Cls { void m() {} };
-    luabridge::getGlobalNamespace(L)
-        .beginNamespace("TblTest")
-            .beginClass<Cls>("Cls")
-                .addFunction("m", &Cls::m)
-            .endClass()
-        .endNamespace();
-
-    int topBefore = lua_gettop(L);
-    luabridge::inspectToLua(L, "TblTest");
-
-    ASSERT_EQ(topBefore + 1, lua_gettop(L));
-    ASSERT_TRUE(lua_istable(L, -1));
-
-    lua_getfield(L, -1, "name");
-    EXPECT_STREQ("TblTest", lua_tostring(L, -1));
-    lua_pop(L, 1);
-
-    lua_getfield(L, -1, "classes");
-    EXPECT_TRUE(lua_istable(L, -1));
-    EXPECT_EQ(1, luabridge::get_length(L, -1));
-    lua_pop(L, 1);
-
-    lua_pop(L, 1); // pop result table
-    EXPECT_EQ(topBefore, lua_gettop(L));
-}
-
-TEST_F(InspectTests, LuaTableVisitorHandlesNestedNamespaces)
-{
-    struct OuterCls { void outerMethod() {} };
-    struct InnerCls { void innerMethod() {} };
-
-    luabridge::getGlobalNamespace(L)
-        .beginNamespace("Outer")
-            .beginClass<OuterCls>("OuterCls")
-                .addFunction("outerMethod", &OuterCls::outerMethod)
-            .endClass()
-            .beginNamespace("Inner")
-                .beginClass<InnerCls>("InnerCls")
-                    .addFunction("innerMethod", &InnerCls::innerMethod)
-                .endClass()
-            .endNamespace()
-        .endNamespace();
-
-    int topBefore = lua_gettop(L);
-    luabridge::inspectToLua(L, "Outer");
-
-    // Stack must grow by exactly 1
-    ASSERT_EQ(topBefore + 1, lua_gettop(L));
-    ASSERT_TRUE(lua_istable(L, -1));
-
-    // Outer namespace name
-    lua_getfield(L, -1, "name");
-    EXPECT_STREQ("Outer", lua_tostring(L, -1));
-    lua_pop(L, 1);
-
-    // Outer classes array contains OuterCls
-    lua_getfield(L, -1, "classes");
-    EXPECT_TRUE(lua_istable(L, -1));
-    EXPECT_EQ(1, luabridge::get_length(L, -1));
-    lua_pop(L, 1);
-
-    // subNamespaces array contains the Inner namespace
-    lua_getfield(L, -1, "subNamespaces");
-    EXPECT_TRUE(lua_istable(L, -1));
-    EXPECT_EQ(1, luabridge::get_length(L, -1));
-
-    // Inspect the Inner sub-namespace table
-    lua_rawgeti(L, -1, 1);
-    ASSERT_TRUE(lua_istable(L, -1));
-
-    lua_getfield(L, -1, "name");
-    EXPECT_STREQ("Inner", lua_tostring(L, -1));
-    lua_pop(L, 1);
-
-    lua_getfield(L, -1, "classes");
-    EXPECT_TRUE(lua_istable(L, -1));
-    EXPECT_EQ(1, luabridge::get_length(L, -1));
-    lua_pop(L, 1);
-
-    lua_pop(L, 1); // pop Inner table
-    lua_pop(L, 1); // pop subNamespaces table
-
-    lua_pop(L, 1); // pop result table
-    EXPECT_EQ(topBefore, lua_gettop(L));
-}
-
 TEST_F(InspectTests, LuaLSVisitorProducesAnnotations)
 {
     struct Cls { int getValue() const { return 0; } };