переход на warcraftxl 1.1

modules/moonwell-fdid/src/FdidOverlay.cpp

@@ -0,0 +1,161 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// FileDataID overlay for selected retail assets shipped in MoonWell patches.
+
+#include "game/Io.hpp"
+#include "wxl/FdidApi.h"
+#include "wxl/PluginApi.h"
+
+#include <windows.h>
+
+#include <charconv>
+#include <cstdint>
+#include <mutex>
+#include <string>
+#include <string_view>
+#include <system_error>
+#include <unordered_map>
+#include <vector>
+
+namespace moonwell::fdid
+{
+    namespace
+    {
+        constexpr std::string_view kFileDataMap = "WXLFileData.csv";
+
+        std::once_flag g_loadOnce;
+        std::unordered_map<uint32_t, std::string> g_paths;
+        const WXL_Api* g_api = nullptr;
+        const char*(__cdecl* g_resolveTexture)(uint32_t) = nullptr;
+        const char*(__cdecl* g_resolveModel)(uint32_t) = nullptr;
+
+        bool ReadAll(const char* path, std::vector<uint8_t>& out)
+        {
+            void* handle = nullptr;
+            if (!wxl::game::io::FileOpen(path, wxl::game::io::kOpenWholeFile, &handle) || !handle)
+                return false;
+            uint32_t high = 0;
+            const uint32_t size = wxl::game::io::FileSize(handle, &high);
+            if (high != 0)
+            {
+                wxl::game::io::FileClose(handle);
+                return false;
+            }
+            out.resize(size);
+            uint32_t read = 0;
+            const bool ok = (size == 0 || wxl::game::io::FileRead(handle, out.data(), size, &read))
+                && read == size;
+            wxl::game::io::FileClose(handle);
+            if (!ok) out.clear();
+            return ok;
+        }
+
+        std::string_view Trim(std::string_view value)
+        {
+            while (!value.empty() && (value.front() == ' ' || value.front() == '\t' ||
+                                      value.front() == '\r' || value.front() == '\n'))
+                value.remove_prefix(1);
+            while (!value.empty() && (value.back() == ' ' || value.back() == '\t' ||
+                                      value.back() == '\r' || value.back() == '\n'))
+                value.remove_suffix(1);
+            return value;
+        }
+
+        void Load()
+        {
+            std::vector<uint8_t> bytes;
+            if (!ReadAll(kFileDataMap.data(), bytes))
+            {
+                if (g_api && g_api->Log)
+                    g_api->Log(WXL_LOG_WARN, "MoonWellFdid", "FileDataID map '%s' was not found",
+                               kFileDataMap.data());
+                return;
+            }
+
+            const std::string_view text(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+            size_t lineStart = 0;
+            while (lineStart < text.size())
+            {
+                size_t lineEnd = text.find('\n', lineStart);
+                if (lineEnd == std::string_view::npos) lineEnd = text.size();
+                std::string_view line = Trim(text.substr(lineStart, lineEnd - lineStart));
+                lineStart = lineEnd + 1;
+
+                if (line.empty() || line.front() == '#') continue;
+                const size_t comma = line.find(',');
+                if (comma == std::string_view::npos) continue;
+
+                const std::string_view idText = Trim(line.substr(0, comma));
+                std::string_view pathText = Trim(line.substr(comma + 1));
+                uint32_t fileDataId = 0;
+                const auto parsed = std::from_chars(idText.data(), idText.data() + idText.size(), fileDataId);
+                if (parsed.ec != std::errc{} || parsed.ptr != idText.data() + idText.size() ||
+                    fileDataId == 0 || pathText.empty())
+                    continue;
+
+                std::string path(pathText);
+                for (char& c : path) if (c == '/') c = '\\';
+                g_paths[fileDataId] = std::move(path);
+            }
+
+            if (g_api && g_api->Log)
+                g_api->Log(WXL_LOG_INFO, "MoonWellFdid", "loaded %zu custom FileDataID path(s)",
+                           g_paths.size());
+        }
+
+        const char* ResolveCustom(uint32_t fileDataId)
+        {
+            std::call_once(g_loadOnce, &Load);
+            const auto found = g_paths.find(fileDataId);
+            return found == g_paths.end() ? nullptr : found->second.c_str();
+        }
+
+        const char* __cdecl ResolveTexture(uint32_t fileDataId)
+        {
+            if (const char* custom = ResolveCustom(fileDataId)) return custom;
+            return g_resolveTexture ? g_resolveTexture(fileDataId) : nullptr;
+        }
+
+        const char* __cdecl ResolveModel(uint32_t fileDataId)
+        {
+            if (const char* custom = ResolveCustom(fileDataId)) return custom;
+            return g_resolveModel ? g_resolveModel(fileDataId) : nullptr;
+        }
+
+        bool PatchResolver(WXL_FdidApi* fdid)
+        {
+            if (!fdid || fdid->apiVersion != WXL_FDID_API_VERSION) return false;
+            g_resolveTexture = fdid->ResolveTexture;
+            g_resolveModel = fdid->ResolveModel;
+
+            DWORD oldProtection = 0;
+            if (!VirtualProtect(fdid, sizeof(*fdid), PAGE_READWRITE, &oldProtection)) return false;
+            fdid->ResolveTexture = &ResolveTexture;
+            fdid->ResolveModel = &ResolveModel;
+            DWORD ignored = 0;
+            VirtualProtect(fdid, sizeof(*fdid), oldProtection, &ignored);
+            return true;
+        }
+    }
+}
+
+const WXL_PluginInfo* __cdecl WXL_Query(void)
+{
+    static const WXL_PluginInfo info = {
+        sizeof(WXL_PluginInfo), WXL_API_VERSION, "MoonWellFdid", 1, WXL_CLIENT_BUILD,
+    };
+    return &info;
+}
+
+int __cdecl WXL_Load(const WXL_Api* api)
+{
+    if (!api || api->apiVersion != WXL_API_VERSION) return 0;
+    moonwell::fdid::g_api = api;
+    auto* fdid = static_cast<WXL_FdidApi*>(api->GetInterface("wxl.fdid", WXL_FDID_API_VERSION));
+    if (!moonwell::fdid::PatchResolver(fdid))
+    {
+        api->Log(WXL_LOG_ERROR, "MoonWellFdid", "wxl.fdid v1 is unavailable");
+        return 0;
+    }
+    api->Log(WXL_LOG_INFO, "MoonWellFdid", "custom FileDataID overlay installed");
+    return 1;
+}

modules/moonwell-storage-fallback/src/StorageFallback.cpp

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// MoonWell's specific-archive fallback, kept outside the WarcraftXL core.
+
+#include "wxl/PluginApi.h"
+
+#include <atomic>
+#include <cstdint>
+
+namespace
+{
+    const WXL_Api* g_api = nullptr;
+    using FileOpenFn = int(__stdcall*)(void* archive, const char* name, uint32_t flags, void** out);
+    FileOpenFn g_nextOpen = nullptr;
+    std::atomic<uint32_t> g_logCount{0};
+
+    int __stdcall FileOpenHook(void* archive, const char* name, uint32_t flags, void** out)
+    {
+        if (!g_nextOpen) return 0;
+
+        const int nativeResult = g_nextOpen(archive, name, flags, out);
+        if (nativeResult || archive == nullptr || !name || !*name) return nativeResult;
+
+        // A dependency requested through one concrete MPQ may live in a higher-priority loose
+        // Patch-*.MPQ directory. Retry only after that exact archive misses, using the client's
+        // normal global search path. This is the MoonWell-only behavior that used to patch core.
+        if (out) *out = nullptr;
+        const int fallbackResult = g_nextOpen(nullptr, name, flags, out);
+        if (fallbackResult && g_api && g_api->Log)
+        {
+            const uint32_t index = g_logCount.fetch_add(1, std::memory_order_relaxed);
+            if (index < 32)
+                g_api->Log(WXL_LOG_INFO, "MoonWellStorageFallback",
+                           "specific archive miss resolved globally: '%s'", name);
+        }
+        return fallbackResult;
+    }
+}
+
+const WXL_PluginInfo* __cdecl WXL_Query(void)
+{
+    static const WXL_PluginInfo info = {
+        sizeof(WXL_PluginInfo), WXL_API_VERSION, "MoonWellStorageFallback", 1,
+        WXL_CLIENT_BUILD,
+    };
+    return &info;
+}
+
+int __cdecl WXL_Load(const WXL_Api* api)
+{
+    if (!api || api->apiVersion != WXL_API_VERSION || !api->HookAttachByName) return 0;
+    g_api = api;
+    const int installed = api->HookAttachByName(
+        "Io.FileOpen", reinterpret_cast<void*>(&FileOpenHook),
+        reinterpret_cast<void**>(&g_nextOpen), WXL_HOOK_DEFAULT_PRIORITY);
+    api->Log(installed ? WXL_LOG_INFO : WXL_LOG_ERROR, "MoonWellStorageFallback", "%s",
+             installed ? "specific-archive fallback installed" : "Io.FileOpen hook failed");
+    return installed;
+}

modules/moonwell/host/FileDataResolver.cpp

@@ -1,95 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-// FileDataID resolver for selected retail assets shipped in MoonWell patches.
-
-#include "Host.hpp"
-#include "core/Logger.hpp"
-#include "mpq/MpqStore.hpp"
-
-#include <charconv>
-#include <cstdint>
-#include <mutex>
-#include <string>
-#include <string_view>
-#include <system_error>
-#include <unordered_map>
-#include <vector>
-
-namespace moonwell::host
-{
-    namespace
-    {
-        constexpr std::string_view kFileDataMap = "WXLFileData.csv";
-
-        std::once_flag g_loadOnce;
-        std::unordered_map<uint32_t, std::string> g_paths;
-
-        std::string_view Trim(std::string_view value)
-        {
-            while (!value.empty() && (value.front() == ' ' || value.front() == '\t' ||
-                                      value.front() == '\r' || value.front() == '\n'))
-                value.remove_prefix(1);
-            while (!value.empty() && (value.back() == ' ' || value.back() == '\t' ||
-                                      value.back() == '\r' || value.back() == '\n'))
-                value.remove_suffix(1);
-            return value;
-        }
-
-        void Load()
-        {
-            const std::string root = wxl::host::ClientRoot();
-            wxl::host::mpq::MpqStore store;
-            std::vector<uint8_t> bytes;
-            if (root.empty() || !store.Mount(root) || !store.ReadAll(kFileDataMap, bytes))
-            {
-                WLOG_WARN("moonwell: FileDataID map '%.*s' was not found",
-                          int(kFileDataMap.size()), kFileDataMap.data());
-                return;
-            }
-
-            const std::string_view text(reinterpret_cast<const char*>(bytes.data()), bytes.size());
-            size_t lineStart = 0;
-            while (lineStart < text.size())
-            {
-                size_t lineEnd = text.find('\n', lineStart);
-                if (lineEnd == std::string_view::npos) lineEnd = text.size();
-                std::string_view line = Trim(text.substr(lineStart, lineEnd - lineStart));
-                lineStart = lineEnd + 1;
-
-                if (line.empty() || line.front() == '#') continue;
-                const size_t comma = line.find(',');
-                if (comma == std::string_view::npos) continue;
-
-                const std::string_view idText = Trim(line.substr(0, comma));
-                std::string_view pathText = Trim(line.substr(comma + 1));
-                uint32_t fileDataId = 0;
-                const auto parsed = std::from_chars(idText.data(), idText.data() + idText.size(), fileDataId);
-                if (parsed.ec != std::errc{} || parsed.ptr != idText.data() + idText.size() ||
-                    fileDataId == 0 || pathText.empty())
-                    continue;
-
-                std::string path(pathText);
-                for (char& c : path) if (c == '/') c = '\\';
-                g_paths[fileDataId] = std::move(path);
-            }
-
-            WLOG_INFO("moonwell: loaded %zu FileDataID path(s) from %.*s",
-                      g_paths.size(), int(kFileDataMap.size()), kFileDataMap.data());
-        }
-
-        bool Resolve(uint32_t fileDataId, std::string& outPath)
-        {
-            std::call_once(g_loadOnce, &Load);
-            const auto found = g_paths.find(fileDataId);
-            if (found == g_paths.end()) return false;
-            outPath = found->second;
-            return true;
-        }
-
-        struct Registrar
-        {
-            Registrar() { wxl::host::RegisterResolver("moonwell-filedata", &Resolve); }
-        };
-
-        Registrar g_registrar;
-    }
-}

modules/moonwell/src/MoonWell.cpp

@@ -5,28 +5,71 @@
 // changes are verified and applied to the process image during WarcraftXL's
 // boot phase, before GlueXML is loaded.
 
-#include "core/Logger.hpp"
-#include "core/Hook.hpp"
-#include "core/Mem.hpp"
-#include "runtime/LuaBindings.hpp"
-#include "runtime/ModuleInstall.hpp"
-#include "offsets/engine/Gx.hpp"
+#include "game/Script.hpp"
+#include "wxl/PluginApi.h"
+#include "SpellOverrides.hpp"
 
 #include <windows.h>
 
 #include <array>
 #include <cstddef>
 #include <cstdint>
+#include <cstdio>
 #include <cstring>
+#include <cstdarg>
 
 namespace moonwell
 {
     namespace
     {
+        const WXL_Api* g_api = nullptr;
+
+        void Log(int level, const char* format, ...)
+        {
+            if (!g_api || !g_api->Log) return;
+            char message[1024]{};
+            va_list args;
+            va_start(args, format);
+            vsnprintf_s(message, sizeof(message), _TRUNCATE, format, args);
+            va_end(args);
+            g_api->Log(level, "MoonWell", "%s", message);
+        }
+
+#define WLOG_INFO(...) Log(WXL_LOG_INFO, __VA_ARGS__)
+#define WLOG_ERROR(...) Log(WXL_LOG_ERROR, __VA_ARGS__)
+
+        bool PatchMemory(void* destination, const void* source, size_t size)
+        {
+            DWORD oldProtection = 0;
+            if (!VirtualProtect(destination, size, PAGE_EXECUTE_READWRITE, &oldProtection))
+                return false;
+            std::memcpy(destination, source, size);
+            FlushInstructionCache(GetCurrentProcess(), destination, size);
+            DWORD ignored = 0;
+            VirtualProtect(destination, size, oldProtection, &ignored);
+            return true;
+        }
+
+        template <class Fn>
+        bool Hook(const char* name, uintptr_t address, Fn* detour, Fn** original)
+        {
+            return g_api && g_api->HookAttach && g_api->HookAttach(
+                name, address, reinterpret_cast<void*>(detour),
+                reinterpret_cast<void**>(original), WXL_HOOK_DEFAULT_PRIORITY) != 0;
+        }
+
+        template <class Fn>
+        bool HookByName(const char* point, Fn* detour, Fn** original)
+        {
+            return g_api && g_api->HookAttachByName && g_api->HookAttachByName(
+                point, reinterpret_cast<void*>(detour), reinterpret_cast<void**>(original),
+                WXL_HOOK_DEFAULT_PRIORITY) != 0;
+        }
+
         constexpr uint32_t kTraitorFlag = 0x40000000u;
         bool g_loginCharacterIsTraitor = false;
 
-        using GxSetProjectionFn = wxl::offsets::engine::gx::GxSetProjectionFn;
+        using GxSetProjectionFn = void(__fastcall*)(void* self, void* edx, const void* projection);
         GxSetProjectionFn g_nextSetProjection = nullptr;
 
         // FrameXML's stock SetCreature only accepts a creature entry and waits
@@ -64,10 +107,10 @@ namespace moonwell
         int __cdecl SetCreatureDisplayInfoHook(void* state)
         {
             const int result = g_nextSetCreature ? g_nextSetCreature(state) : 0;
-            if (!state || !wxl::runtime::lua::IsNumber(state, 3))
+            if (!state || !wxl::game::script::IsNumber(state, 3))
                 return result;
 
-            const double requestedDisplayInfo = wxl::runtime::lua::ToNumber(state, 3);
+            const double requestedDisplayInfo = wxl::game::script::ToNumber(state, 3);
             if (requestedDisplayInfo <= 0.0 || requestedDisplayInfo > 4294967295.0)
                 return result;
 
@@ -102,8 +145,8 @@ namespace moonwell
 
         void InstallEncounterJournalModelPreview()
         {
-            if (!wxl::core::hook::Install("MoonWellSetCreatureDisplayInfo", kSetCreature,
-                                          &SetCreatureDisplayInfoHook, &g_nextSetCreature))
+            if (!Hook("MoonWellSetCreatureDisplayInfo", kSetCreature,
+                      &SetCreatureDisplayInfoHook, &g_nextSetCreature))
             {
                 WLOG_ERROR("moonwell: encounter journal model hook installation failed");
                 return;
@@ -151,14 +194,14 @@ namespace moonwell
 
         int __cdecl SetCharacterCreateCamera(void* state)
         {
-            const bool enabled = state && wxl::runtime::lua::IsNumber(state, 1)
-                && wxl::runtime::lua::ToNumber(state, 1) != 0.0;
-            const float faceZoom = state && wxl::runtime::lua::IsNumber(state, 2)
-                ? static_cast<float>(wxl::runtime::lua::ToNumber(state, 2)) : 2.0f;
-            const float faceVerticalOffset = state && wxl::runtime::lua::IsNumber(state, 3)
-                ? static_cast<float>(wxl::runtime::lua::ToNumber(state, 3)) : -0.65f;
-            double requestedDuration = state && wxl::runtime::lua::IsNumber(state, 4)
-                ? wxl::runtime::lua::ToNumber(state, 4) : 500.0;
+            const bool enabled = state && wxl::game::script::IsNumber(state, 1)
+                && wxl::game::script::ToNumber(state, 1) != 0.0;
+            const float faceZoom = state && wxl::game::script::IsNumber(state, 2)
+                ? static_cast<float>(wxl::game::script::ToNumber(state, 2)) : 2.0f;
+            const float faceVerticalOffset = state && wxl::game::script::IsNumber(state, 3)
+                ? static_cast<float>(wxl::game::script::ToNumber(state, 3)) : -0.65f;
+            double requestedDuration = state && wxl::game::script::IsNumber(state, 4)
+                ? wxl::game::script::ToNumber(state, 4) : 500.0;
             if (requestedDuration < 0.0) requestedDuration = 0.0;
             if (requestedDuration > 2000.0) requestedDuration = 2000.0;
 
@@ -202,15 +245,16 @@ namespace moonwell
 
         void InstallCharacterCreateCamera()
         {
-            namespace gx = wxl::offsets::engine::gx;
-            void** vtable = reinterpret_cast<void**>(gx::kGxDeviceVTable);
-            void** slot = &vtable[gx::kGxSetProjectionSlot];
+            constexpr uintptr_t kGxDeviceVTable = 0x00A2E718;
+            constexpr unsigned kGxSetProjectionSlot = 0xA0 / 4;
+            void** vtable = reinterpret_cast<void**>(kGxDeviceVTable);
+            void** slot = &vtable[kGxSetProjectionSlot];
             if (*slot == reinterpret_cast<void*>(&CharacterCreateProjectionHook))
                 return;
 
             g_nextSetProjection = reinterpret_cast<GxSetProjectionFn>(*slot);
             void* replacement = reinterpret_cast<void*>(&CharacterCreateProjectionHook);
-            if (!g_nextSetProjection || !wxl::core::mem::Patch(slot, &replacement, sizeof(replacement)))
+            if (!g_nextSetProjection || !PatchMemory(slot, &replacement, sizeof(replacement)))
             {
                 g_nextSetProjection = nullptr;
                 WLOG_ERROR("moonwell: character-create projection hook installation failed");
@@ -222,17 +266,17 @@ namespace moonwell
         int __cdecl SetLoginCharacterFlags(void* state)
         {
             uint32_t flags = 0;
-            if (state && wxl::runtime::lua::IsNumber(state, 1))
-                flags = static_cast<uint32_t>(wxl::runtime::lua::ToNumber(state, 1));
+            if (state && wxl::game::script::IsNumber(state, 1))
+                flags = static_cast<uint32_t>(wxl::game::script::ToNumber(state, 1));
 
             g_loginCharacterIsTraitor = (flags & kTraitorFlag) != 0;
-            wxl::runtime::lua::PushBoolean(state, g_loginCharacterIsTraitor ? 1 : 0);
+            wxl::game::script::PushBoolean(state, g_loginCharacterIsTraitor);
             return 1;
         }
 
         int __cdecl IsTraitor(void* state)
         {
-            wxl::runtime::lua::PushBoolean(state, g_loginCharacterIsTraitor ? 1 : 0);
+            wxl::game::script::PushBoolean(state, g_loginCharacterIsTraitor);
             return 1;
         }
 
@@ -259,7 +303,7 @@ namespace moonwell
                            name, reinterpret_cast<void*>(address));
                 return false;
             }
-            if (!wxl::core::mem::Patch(reinterpret_cast<void*>(address), replacement.data(), N))
+            if (!PatchMemory(reinterpret_cast<void*>(address), replacement.data(), N))
             {
                 WLOG_ERROR("moonwell: '%s' patch failed at %p", name,
                            reinterpret_cast<void*>(address));
@@ -371,7 +415,7 @@ namespace moonwell
             const auto caveRel = static_cast<int32_t>(reinterpret_cast<uintptr_t>(cave) -
                 (patchAddress + jump.size()));
             std::memcpy(jump.data() + 1, &caveRel, sizeof(caveRel));
-            if (!wxl::core::mem::Patch(reinterpret_cast<void*>(patchAddress), jump.data(), jump.size()))
+            if (!PatchMemory(reinterpret_cast<void*>(patchAddress), jump.data(), jump.size()))
             {
                 VirtualFree(cave, 0, MEM_RELEASE);
                 WLOG_ERROR("moonwell: GetCharacterInfo jump patch failed");
@@ -390,40 +434,84 @@ namespace moonwell
                 WLOG_ERROR("moonwell: compatibility module incomplete; see mismatches above");
             else
                 WLOG_INFO("moonwell: compatibility module ready (stock Wow.exe remains untouched)");
-            wxl::core::log::Flush();
         }
 
-        DWORD WINAPI FlushRuntimeLog(LPVOID)
+        using RegisterFunctionFn = void(__cdecl*)(const char*, wxl::game::script::Function);
+        using ValidateCallbackFn = void(__cdecl*)(uintptr_t);
+        using GetContextFn = void*(__cdecl*)();
+        RegisterFunctionFn g_nextRegisterFunction = nullptr;
+        ValidateCallbackFn g_nextValidateCallback = nullptr;
+        void* g_registeredState = nullptr;
+        bool g_registeringMoonWell = false;
+
+        bool IsMoonWellCallback(uintptr_t callback)
         {
-            // Let the remainder of RunAll() and the core-ready line reach the
-            // shared buffered logger, then make startup diagnostics durable.
-            Sleep(1000);
-            wxl::core::log::Flush();
-            return 0;
+            return callback == reinterpret_cast<uintptr_t>(&SetLoginCharacterFlags)
+                || callback == reinterpret_cast<uintptr_t>(&IsTraitor)
+                || callback == reinterpret_cast<uintptr_t>(&SetCharacterCreateCamera);
         }
 
-        void InstallRuntimeLogFlush()
+        void __cdecl ValidateCallbackHook(uintptr_t callback)
         {
-            HANDLE thread = CreateThread(nullptr, 0, &FlushRuntimeLog, nullptr, 0, nullptr);
-            if (thread) CloseHandle(thread);
+            if (!IsMoonWellCallback(callback) && g_nextValidateCallback)
+                g_nextValidateCallback(callback);
         }
 
-        struct Registration
+        void RegisterLuaFunctionsForCurrentState()
         {
-            Registration()
-            {
-                wxl::runtime::lua::RegisterFunction(
-                    "MoonWellSetLoginCharacterFlags", &SetLoginCharacterFlags);
-                wxl::runtime::lua::RegisterFunction("MoonWellIsTraitor", &IsTraitor);
-                wxl::runtime::lua::RegisterFunction(
-                    "MoonWellSetCharacterCreateCamera", &SetCharacterCreateCamera);
-                wxl::runtime::modules::RegisterBoot("moonwell", &InstallBoot);
-                wxl::runtime::modules::Register(
-                    "moonwell-character-create-camera", &InstallCharacterCreateCamera);
-                wxl::runtime::modules::Register(
-                    "moonwell-encounter-journal-models", &InstallEncounterJournalModelPreview);
-                wxl::runtime::modules::Register("moonwell-log-flush", &InstallRuntimeLogFlush);
-            }
-        } g_registration;
+            if (!g_nextRegisterFunction || g_registeringMoonWell) return;
+            constexpr uintptr_t kGetContext = 0x00817DB0;
+            void* state = reinterpret_cast<GetContextFn>(kGetContext)();
+            if (!state || state == g_registeredState) return;
+
+            g_registeringMoonWell = true;
+            g_nextRegisterFunction("MoonWellSetLoginCharacterFlags", &SetLoginCharacterFlags);
+            g_nextRegisterFunction("MoonWellIsTraitor", &IsTraitor);
+            g_nextRegisterFunction("MoonWellSetCharacterCreateCamera", &SetCharacterCreateCamera);
+            g_registeringMoonWell = false;
+            g_registeredState = state;
+            WLOG_INFO("moonwell: Lua functions registered for state %p", state);
+        }
+
+        void __cdecl RegisterFunctionHook(const char* name, wxl::game::script::Function function)
+        {
+            if (g_nextRegisterFunction) g_nextRegisterFunction(name, function);
+            RegisterLuaFunctionsForCurrentState();
+        }
+
+        bool InstallLuaBridge()
+        {
+            const bool validator = HookByName("Lua.ValidateFunctionPointer", &ValidateCallbackHook,
+                                              &g_nextValidateCallback);
+            const bool registrar = HookByName("Lua.RegisterFunction", &RegisterFunctionHook,
+                                              &g_nextRegisterFunction);
+            if (!validator || !registrar)
+                WLOG_ERROR("moonwell: Lua bridge hook installation failed");
+            return validator && registrar;
+        }
     }
 }
+
+const WXL_PluginInfo* __cdecl WXL_Query(void)
+{
+    static const WXL_PluginInfo info = {
+        sizeof(WXL_PluginInfo), WXL_API_VERSION, "MoonWell", 1, WXL_CLIENT_BUILD,
+    };
+    return &info;
+}
+
+int __cdecl WXL_Load(const WXL_Api* api)
+{
+    if (!api || api->apiVersion != WXL_API_VERSION) return 0;
+    moonwell::g_api = api;
+
+    moonwell::InstallBoot();
+    const bool lua = moonwell::InstallLuaBridge();
+    moonwell::InstallCharacterCreateCamera();
+    moonwell::InstallEncounterJournalModelPreview();
+    const bool spells = moonwell::spells::Install(api);
+    const bool ready = lua && spells;
+    api->Log(ready ? WXL_LOG_INFO : WXL_LOG_ERROR, "MoonWell", "%s",
+             ready ? "MoonWell extension loaded" : "MoonWell extension loaded with errors");
+    return ready ? 1 : 0;
+}

modules/moonwell/src/SpellOverrides.cpp

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Appends compact MoonWell spell overrides to the stock 3.3.5 DBCs at open time.
+// Appends compact MoonWell spell overrides to stock 3.3.5 DBC bytes.
 
-#include "Host.hpp"
-#include "core/Logger.hpp"
-#include "mpq/MpqStore.hpp"
+#include "game/Io.hpp"
+#include "wxl/PluginApi.h"
+#include "wxl/StorageApi.h"
 
 #include <cctype>
 #include <charconv>
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <vector>
 
-namespace moonwell::host
+namespace moonwell::spells
 {
     namespace
     {
@@ -38,8 +38,34 @@ namespace moonwell::host
 
         std::once_flag g_loadOnce;
         bool g_ready = false;
-        std::vector<uint8_t> g_spellDbc;
-        std::vector<uint8_t> g_skillDbc;
+        const WXL_Api* g_api = nullptr;
+        std::vector<Override> g_overrides;
+
+        void Log(int level, const char* message)
+        {
+            if (g_api && g_api->Log) g_api->Log(level, "MoonWellSpells", "%s", message);
+        }
+
+        bool ReadAll(const char* path, std::vector<uint8_t>& out)
+        {
+            void* handle = nullptr;
+            if (!wxl::game::io::FileOpen(path, wxl::game::io::kOpenWholeFile, &handle) || !handle)
+                return false;
+            uint32_t high = 0;
+            const uint32_t size = wxl::game::io::FileSize(handle, &high);
+            if (high != 0)
+            {
+                wxl::game::io::FileClose(handle);
+                return false;
+            }
+            out.resize(size);
+            uint32_t read = 0;
+            const bool ok = (size == 0 || wxl::game::io::FileRead(handle, out.data(), size, &read))
+                && read == size;
+            wxl::game::io::FileClose(handle);
+            if (!ok) out.clear();
+            return ok;
+        }
 
         uint32_t ReadU32(const uint8_t* data)
         {
@@ -226,39 +252,59 @@ namespace moonwell::host
 
         void Load()
         {
-            const std::string root = wxl::host::ClientRoot();
-            wxl::host::mpq::MpqStore store;
-            std::vector<uint8_t> overrideBytes, spellBase, skillBase;
-            if (root.empty() || !store.Mount(root) || !store.ReadAll(kOverridesPath, overrideBytes))
+            std::vector<uint8_t> overrideBytes;
+            if (!ReadAll(kOverridesPath.data(), overrideBytes))
                 return;
 
-            std::vector<Override> overrides;
-            if (!ParseOverrides(overrideBytes, overrides) ||
-                !store.ReadAll(kSpellPath, spellBase) || !store.ReadAll(kSkillPath, skillBase) ||
-                !BuildSpellDbc(spellBase, overrides, g_spellDbc) ||
-                !BuildSkillDbc(skillBase, overrides, g_skillDbc))
+            if (!ParseOverrides(overrideBytes, g_overrides))
             {
-                WLOG_ERROR("moonwell-spells: failed to build custom companion DBCs");
+                Log(WXL_LOG_ERROR, "failed to parse WXLSpellOverrides.tsv");
                 return;
             }
             g_ready = true;
-            WLOG_INFO("moonwell-spells: appended %zu companion spell(s)", overrides.size());
+            if (g_api && g_api->Log)
+                g_api->Log(WXL_LOG_INFO, "MoonWellSpells", "loaded %zu companion spell override(s)",
+                           g_overrides.size());
         }
 
-        bool Provide(std::string_view name, std::vector<uint8_t>& out)
+        int __cdecl Transform(const char* rawName, const uint8_t* raw, uint32_t rawLen,
+                              const WXL_ByteSink* sink)
         {
+            if (!rawName || !raw || !sink || !sink->Write) return 0;
+            const std::string_view name(rawName);
             if (!SamePath(name, kSpellPath) && !SamePath(name, kSkillPath)) return false;
             std::call_once(g_loadOnce, &Load);
             if (!g_ready) return false;
-            out = SamePath(name, kSpellPath) ? g_spellDbc : g_skillDbc;
-            return true;
+
+            const std::vector<uint8_t> base(raw, raw + rawLen);
+            std::vector<uint8_t> out;
+            const bool built = SamePath(name, kSpellPath)
+                ? BuildSpellDbc(base, g_overrides, out)
+                : BuildSkillDbc(base, g_overrides, out);
+            if (!built)
+            {
+                Log(WXL_LOG_ERROR, "failed to build custom companion DBC");
+                return 0;
+            }
+            sink->Write(sink->ctx, out.data(), static_cast<uint32_t>(out.size()));
+            return 1;
         }
+    }
 
-        struct Registrar
+    bool Install(const WXL_Api* api)
+    {
+        g_api = api;
+        if (!api || !api->GetInterface) return false;
+        auto* storage = static_cast<WXL_StorageApi*>(
+            api->GetInterface("wxl.storage", WXL_STORAGE_API_VERSION));
+        if (!storage || storage->apiVersion != WXL_STORAGE_API_VERSION ||
+            !storage->RegisterClientTransform)
         {
-            Registrar() { wxl::host::RegisterProvider("moonwell-companion-spells", &Provide); }
-        };
-
-        Registrar g_registrar;
+            Log(WXL_LOG_ERROR, "wxl.storage v1 is unavailable");
+            return false;
+        }
+        storage->RegisterClientTransform(".dbc", &Transform);
+        Log(WXL_LOG_INFO, "DBC override transform registered");
+        return true;
     }
 }

modules/moonwell/src/SpellOverrides.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+struct WXL_Api;
+
+namespace moonwell::spells
+{
+    bool Install(const WXL_Api* api);
+}

modules/wxl-modern-blp/shared.cmake

@@ -0,0 +1,2 @@
+file(GLOB_RECURSE WXL_EXT_SHARED_SRC CONFIGURE_DEPENDS
+     "${CMAKE_CURRENT_SOURCE_DIR}/src/engine/assets/shared/textures/blp/*.cpp")

modules/wxl-modern-blp/src/Module.cpp

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// WarcraftXL 1.1 BLP transform extension.
+
+#include "engine/assets/shared/textures/blp/BlpTranscode.hpp"
+#include "wxl/ModernBlpApi.h"
+#include "wxl/PluginApi.h"
+#include "wxl/StorageApi.h"
+
+#include <cstdint>
+#include <span>
+#include <utility>
+#include <vector>
+
+namespace
+{
+    const WXL_Api* g_api = nullptr;
+    constexpr uint32_t kMaxTextureEdge = 1024;
+
+    int __cdecl Transcode(const char* name, const uint8_t* raw, uint32_t rawLen,
+                          const WXL_ByteSink* sink)
+    {
+        if (!raw || !sink || !sink->Write) return 0;
+        namespace blp = wxl::modern::assets::textures::blp;
+
+        const std::span<const uint8_t> input(raw, rawLen);
+        std::vector<uint8_t> capped;
+        const bool didCap = blp::CapBlpMips(input, capped, kMaxTextureEdge);
+        const std::span<const uint8_t> source = didCap
+            ? std::span<const uint8_t>(capped.data(), capped.size()) : input;
+
+        std::vector<uint8_t> transcoded;
+        if (blp::TranscodeBlp(source, transcoded))
+        {
+            sink->Write(sink->ctx, transcoded.data(), static_cast<uint32_t>(transcoded.size()));
+            if (g_api && g_api->Log)
+                g_api->Log(WXL_LOG_DEBUG, "wxl-modern-blp", "%s%s BGRA->DXT5",
+                           name ? name : "?", didCap ? " capped" : "");
+            return 1;
+        }
+        if (!didCap) return 0;
+
+        sink->Write(sink->ctx, capped.data(), static_cast<uint32_t>(capped.size()));
+        return 1;
+    }
+
+    const WXL_ModernBlpApi g_blpApi = {
+        sizeof(WXL_ModernBlpApi), WXL_MODERN_BLP_API_VERSION, &Transcode,
+    };
+}
+
+const WXL_PluginInfo* __cdecl WXL_Query(void)
+{
+    static const WXL_PluginInfo info = {
+        sizeof(WXL_PluginInfo), WXL_API_VERSION, "wxl-modern-blp", 1, WXL_CLIENT_BUILD,
+    };
+    return &info;
+}
+
+int __cdecl WXL_Load(const WXL_Api* api)
+{
+    if (!api || api->apiVersion != WXL_API_VERSION) return 0;
+    g_api = api;
+    auto* storage = static_cast<WXL_StorageApi*>(
+        api->GetInterface("wxl.storage", WXL_STORAGE_API_VERSION));
+    if (!storage || storage->apiVersion != WXL_STORAGE_API_VERSION ||
+        !storage->RegisterClientTransform)
+    {
+        api->Log(WXL_LOG_ERROR, "wxl-modern-blp", "wxl.storage v1 is unavailable");
+        return 0;
+    }
+
+    storage->RegisterClientTransform(".blp", &Transcode);
+    api->PublishInterface("wxl.modern-blp", WXL_MODERN_BLP_API_VERSION,
+                          const_cast<WXL_ModernBlpApi*>(&g_blpApi));
+    api->Log(WXL_LOG_INFO, "wxl-modern-blp", "BLP transcode and mip cap active");
+    return 1;
+}